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;

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

INSTALL @lib$+"TIMERLIB"

INSTALL @lib$+"NOWAIT"

{{libheader|pthread}}

#include <stdlib.h>

#include <unistd.h>

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

{{works with|C# 6}}

using System.Threading.Tasks;

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

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

#include <chrono>

#include <cmath>

=={{header|Clojure}}==

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

{{libheader|Bordeaux Threads}}

(defclass integrator ()

((input :initarg :input :writer input :reader %input)

{{trans|Python}}

Crystal currently runs all code in a single thread, so a trivial example wouldn't have any issues with thread safety. However, this behavior will likely change in the future. This example was written with that in mind, and is somewhat more complex to show better idioms and be future-proof.

require "time"

=={{header|D}}==

{{trans|Java}}

import std.datetime;

import std.math;

{{libheader| System.Classes}}

{{Trans|Python}}

program Active_object;

=={{header|E}}==

var value := 0.0

var input := fn { 0.0 }

=={{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)

</syntaxhighlight>

{{Out}}

(define (experiment)

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

=={{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] ).

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

open System.Threading

=={{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

=={{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>

=={{header|FreeBASIC}}==

dim shared as double S = 0 'set up the state as a global variable

dim shared as double t0, t1, ta

=={{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 (

=={{header|Groovy}}==

{{trans|Java}}

* Integrates input function K over time

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

=={{header|Haskell}}==

newIntegrator, input, output, stop,

Time, timeInterval

Implementation:

require'dates'

Task example (code):

delay=: 6!:3

=={{header|Java}}==

* Integrates input function K over time

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

{{trans|E}}

var inputF = function () { return 0.0 };

var sum = 0.0;

Test program as a HTML fragment:

<script type="text/javascript">

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

{{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.*

=={{header|Lingo}}==

Parent script "Integrator":

property _func

property _timeLast

In some movie script:

-- entry point

=={{header|Lua}}==

Pure/native Lua is not multithreaded, so this task should perhaps be marked "omit from|Lua" if following the implicit ''intent'' of the task. However, the explicit ''wording'' of the task does not seem to require a multithreaded solution. Perhaps this is ''cheating'', but I thought it might interest the reader to see the integrator portion nonetheless, so it is demonstrated using a mock sampling method at various intervals (to ''simulate'' multithreaded updates).

local integrator = {

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

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

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

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

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

double MainTime

=={{header|Oz}}==

fun {Const X}

fun {$ _} X end

=={{header|Perl}}==

use strict;

{{libheader|Phix/Class}}

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.2"</span><span style="color: #0000FF;">)</span>

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

<span style="color: #008080;">enum</span> <span style="color: #000000;">TERMINATE</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">INTERVAL</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">KFUN</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">VALUE</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">T0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">K0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ID</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ISIZE</span><span style="color: #0000FF;">=$</span>

=={{header|PicoLisp}}==

(class +Active)

=={{header|PureBasic}}==

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

Class IntegralClass

from threading import Thread

=={{header|Racket}}==

#lang racket

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;

=={{header|Rust}}==

extern crate num;

=={{header|Scala}}==

class Integrator {

=={{header|Smalltalk}}==

Object subclass:#Integrator

instanceVariableNames:'tickRate input s thread'

</syntaxhighlight>

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

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

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

Sub Main()

What I've done instead is to pre-compute the number of updates performed on my machine for a given function and time period which is a fairly stable figure (though it will obviously be different on other machines). I've then used this figure to measure elapsed time for each update. On average this gives results of around 0.003 seconds which I consider acceptable in the circumstances.

import "timer" for Timer

{{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 setF(f) { K.set(f) }

}</syntaxhighlight>

Atomic.sleep(2);

ai.sample().println();

</pre>

{{omit from|6502 Assembly|Not an object-oriented language.}}

{{omit from|8080 Assembly}}

{{omit from|8086 Assembly}}

{{omit from|ACL2}}

{{omit from|ARM Assembly}}

{{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|x86 Assembly}}

{{omit from|Z80 Assembly}}