Active object: Difference between revisions

{{task|Concurrency}}

 

In [[object-oriented programming]] an object is active when its state depends on clock. Usually an active object encapsulates a [[task]] that updates the object's state. To the outer world the object looks like a normal object with methods that can be called from outside. Implementation of such methods must have a certain synchronization mechanism with the encapsulated task in order to prevent object's state corruption.

Verify that now the object's output is approximately 0 (the sine has the period of 2s). The accuracy of the result will depend on the [[OS]] scheduler time slicing and the accuracy of the clock.

 

 

=={{header|Ada}}==

with Ada.Numerics; use Ada.Numerics;

with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;

Put_Line ("Integrated" & Float'Image (S) & "s");

I.Shut_Down;

Sample output:

<pre>

</pre>

 

{{works with|BBC BASIC for Windows}}

INSTALL @lib$+"TIMERLIB"

INSTALL @lib$+"NOWAIT"

PROCwait(50)

PRINT "Final value = " FN(myinteg.output)

Output:

<pre>

{{libheader|pthread}}

 

#include <stdlib.h>

#include <unistd.h>

 

return 0;

output

<pre>-9.99348e-05</pre>

=={{header|C sharp|C#}}==

{{works with|C# 6}}

using System.Threading.Tasks;

 

Console.WriteLine(ao.Value);

}

 

Output:

=={{header|C++}}==

{{works with|C++14|}}

#include <chrono>

#include <cmath>

void Integrator::do_work()

{

integrate();

std::this_thread::sleep_for(1ms);

dur_t start = t_prev - beginning;

dur_t fin = now - beginning;

state += (func(start.count()) + func(fin.count())) * (fin - start).count() / 2;

t_prev = now;

std::this_thread::sleep_for(500ms);

std::cout << foo.output();

output

<pre>1.23136e-011</pre>

 

=={{header|Clojure}}==

(:import (java.util Timer TimerTask)))

 

user> (test-integrator)

1.414065859052494E-5

 

=={{header|D}}==

{{trans|Java}}

import std.datetime;

import std.math;

v0 = v1;

}

 

{{out}}

{{libheader| System.Classes}}

{{Trans|Python}}

program Active_object;

 

Integrator.Join;

Readln;

{{out}}

<pre>

=={{header|E}}==

 

var value := 0.0

var input := fn { 0.0 }

})

return result

 

=={{header|EchoLisp}}==

We use the functions (at ..) : scheduling, (wait ...), and (every ...) ot the timer.lib. The accuracy will be function of the browser's functions setTimeout and setInterval ...

(require 'timer)

(else (error "active:bad message" message))))))

{{Out}}

(define (experiment)

(define (K t) (sin (* PI t )))

3/7/2015 20:34:28 : result

result 0.00026510586971023164

 

=={{header|Erlang}}==

I could not see what time to use between each integration so it is the argument to task().

-module( active_object ).

-export( [delete/1, input/2, new/0, output/1, task/1] ).

 

zero( _ ) -> 0.

 

=={{header|F_Sharp|F#}}==

open System.Threading

 

 

printfn "%f" (i.Output())

 

=={{header|Factor}}==

Working with dynamic quotations requires the stack effect to be known in advance. The apply-stack-effect serves this purpose.

math.constants math.functions prettyprint system threads ;

IN: rosettacode.active

0.5 seconds sleep

[ output . ] [ destroy ] bi ;

( scratchpad ) "rosettacode.active" run

-5.294207647335787e-05

=={{header|FBSL}}==

The Dynamic Assembler and Dynamic C JIT compilers integrated in FBSL v3.5 handle multithreading perfectly well. However, pure FBSL infrastructure has never been designed especially to support own multithreading nor can it handle long long integers natively. Yet a number of tasks with careful design and planning are quite feasible in pure FBSL too:

 

#INCLUDE <Include\Windows.inc>

FUNCTION Task(BYVAL t AS DOUBLE) AS DOUBLE

RETURN SIN(2 * PI * 0.5 * t)

 

'''Typical console output:'''

>>> -0.000769965989580346

Press any key to continue...

 

=={{header|Go}}==

Using time.Tick to sample K at a constant frequency. Three goroutines are involved, main, aif, and tk. Aif controls access to the accumulator s and the integration function K. Tk and main must talk to aif through channels to access s and K.

 

import (

time.Sleep(time.Second / 2) // 4. sleep .5 sec

fmt.Println(a.output()) // output should be near zero

Output:

<pre>

=={{header|Groovy}}==

{{trans|Java}}

* Integrates input function K over time

* S + (t1 - t0) * (K(t1) + K(t0)) / 2

System.out.println(integrator.getOutput())

}

{{out}}

<pre>0.0039642136156300455</pre>

=={{header|Haskell}}==

 

newIntegrator, input, output, stop,

Time, timeInterval

 

-- Execute 'action' until it returns false.

 

=={{header|J}}==

Implementation:

 

require'dates'

 

getoutput=:3 :0

Zero+G T''

 

Task example (code):

 

 

delay=: 6!:3

delay 0.5

 

 

Task example (output):

 

First column is time relative to start of processing, second column is object's output at that time.

 

=={{header|Java}}==

* Integrates input function K over time

* S + (t1 - t0) * (K(t1) + K(t0)) / 2

}

}

Output:

<pre>4.783602720556498E-13</pre>

{{trans|E}}

 

var inputF = function () { return 0.0 };

var sum = 0.0;

shutdown: function () { clearInterval(updater) },

});

 

Test program as a HTML fragment:

 

 

<script type="text/javascript">

}, 2000);

}, 1)

 

=={{header|Julia}}==

Julia has inheritance of data structures and first-class types, but structures do not have methods.

Instead, methods are functions with multiple dispatch based on argument type.

func::Function

runningsum::Float64

sleep(0.5)

v2 = it.runningsum

 

=={{header|Kotlin}}==

{{trans|Java}}

Athough this is a faithful translation of the Java entry, on my machine the output of the latter is typically an order of magnitude smaller than this version. I have no idea why.

 

import kotlin.math.*

integrator.stop()

println(integrator.getOutput())

 

Sample output:

=={{header|Lingo}}==

Parent script "Integrator":

property _func

property _timeLast

me._timeLast = t

me._valueLast = val

 

In some movie script:

 

-- entry point

put gIntegrator.output()

timer.forget()

 

{{out}}

<pre>-- 0.0004</pre>

 

K[t_] = Sin[2 Pi f t] /. f -> 0.5; kt0 = K[t0];

While[True, t1 = SessionTime[] - start;

S += (kt0 + (kt0 = K[t1])) (t1 - t0)/2; t0 = t1;

 

1.1309*10^-6

Of course, it is necessary to take some precautions when accessing or updating the shared object. We use a lock for this purpose.

 

# Active object.

# Compile with "nim c --threads:on".

echo "Value after 0.5 more second: ", integrator.output()

integrator.destroy()

 

{{out}}

Not totally certain this is a correct implementation since the value coming out is not close to zero. It does show all of the basics of multithreading and object synchronization though.

 

integrater = .integrater~new(.routines~sine) -- start the integrater function

call syssleep 2

::requires rxmath library

 

 

=={{header|OxygenBasic}}==

 

With a high precision timer the result is around -.0002

double MainTime

 

print str(integral,4)

 

 

=={{header|Oz}}==

fun {Const X}

fun {$ _} X end

 

{Show {I output($)}}

 

=={{header|Perl}}==

 

use strict;

say "0 after .5 seconds: ", $x->output;

 

 

=={{header|Phix}}==

===classes===

 

 

Note that were f a regular member function of the class, it would get a "this" parameter/argument, which we avoid by stashing it in a local integer prior to the call. Alternatively you could of course use zero/sine functions with an ignored parameter and the usual this.f() syntax [along with the usual "this." being optional inside the class definition].

{{out}}

If anything phix requires more locking that other languages due to the hidden shared reference counts.<br>

Just lock everything, it is not that hard, and you should never need much more than the stuff below.

 

 

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(class +Active)

(wait 500) # Wait 0.5 sec

(prinl "Output: " (output> Obj)) # Print return value

 

=={{header|PureBasic}}==

Using the open-source precompiler [http://www.development-lounge.de/viewtopic.php?t=5915 SimpleOOP].

 

Class IntegralClass

Delay( 500) ; Wait 1/2 sec

MessageRequester("Info", StrD(*a\Output())) ; Present the result

 

=={{header|Python}}==

Assignment is thread-safe in Python, so no extra locks are needed in this case.

 

 

from threading import Thread

 

ai = Integrator(lambda t: sin(pi*t))

sleep(2)

ai.K = lambda t: 0

sleep(0.5)

 

=={{header|Racket}}==

 

#lang racket

 

(sleep/yield 0.5)

(displayln (send active output))

 

=={{header|Raku}}==

There is some jitter in the timer, but it is typically accurate to within a few thousandths of a second.

 

has $.f is rw = sub ($t) { 0 };

has $.now is rw;

sleep .5;

 

 

{{out|Typical output}}

=={{header|Rust}}==

 

 

extern crate num;

thread::sleep(Duration::from_millis(100));

assert_eq!(object.output() as u32, 0)

 

=={{header|Scala}}==

 

 

class Integrator {

integrator.bye

}

 

=={{header|Smalltalk}}==

 

Object subclass:#Integrator

instanceVariableNames:'tickRate input s thread'

showCR:(i stop).

].

running:

 

output:

=={{header|SuperCollider}}==

Instead of writing a class, here we just use an environment to encapsulate state.

(

a = TaskProxy { |envir|

}

)

 

=={{header|Swift}}==

import Foundation

// For PI and sin

 

println(activeObject.Output())

Sample output:

<pre>

 

This implementation Tcl 8.6 for object support (for the active integrator object) and coroutine support (for the controller task). It could be rewritten to only use 8.5 plus the TclOO library.

oo::class create integrator {

variable e sum delay tBase t0 k0 aid

pause 0.5

puts [format %.15f [i output]]

Sample output:

-0.000000168952702

Since this object is CPU intensive, shutting it down when done is crucial. To facilitate this, the IDisposable pattern was used.

 

Sub Main()

End Sub

 

 

Output: 0.000241446762282308

 

=={{header|zkl}}==

{{trans|Python}}

Uses cheese ball thread safety: since the integrator runs continuously and I don't want to queue the output, just sample it, strong references are used as they change atomically.

// continuously integrate a function `K`, at each `interval` seconds'

fcn init(f,interval=1e-4){

fcn sample { S.value }

fcn setF(f) { K.set(f) }

Atomic.sleep(2);

ai.sample().println();

ai.setF(fcn{ 0 });

Atomic.sleep(0.5);

{{out}}

<pre>

1.11571e-07

</pre>

{{omit from|ACL2}}

{{omit from|AWK}}

{{omit from|gnuplot}}

{{omit from|LaTeX}}

{{omit from|Locomotive Basic}}

{{omit from|M4}}

{{omit from|Maxima}}

{{omit from|ML/I}}

{{omit from|Octave}}

{{omit from|PlainTeX}}

{{omit from|Retro}}

{{omit from|UNIX Shell}}

{{omit from|ZX Spectrum Basic}}