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>

 

{{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|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|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:'''

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>

2.4517135756807704e-05

</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.

 

 

 

* Integrates input function K over time

*/

public class Integrator {

 

 

 

 

 

 

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)

 

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

Curiously, this value never changes; it is always exactly the same (at 1.1309E-6). Note that closer answers could be achieved by using Mathematica's better interpolation methods, but it would require collecting the data (in a list), which would have a speed penalty large enough to negate the improved estimation.

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|ooRexx}}==

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|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|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}}