## Logistic Actor

The Logistic Actor implements a simple chaotic feedback system. It sends the output of a logistic equation to a message group assigned to it. The equation is: xn = R xn-1 (1-xn-1), where xn is the state of the system, and R is the control variable. The actual output yn can be a linear function of the state, or a discretized bin number, to be described below.

To use the Logistic Actor, load logistic.so and create an actor of type LogisticActor. Because the actor does not have any timing mechanism, you have to use another actor such as the sequence actor or the loop actor to drive the logistic actor.

### Logistic Actor messages

In addition to the messages understood by all actors, the Logistic Actor understand the following messages:

SetMessageGroup `hActor "msg_name"`
  Set the message group to which the logistic actor sends its output as the one and only parameter. To use that value, simply "`AddMessage msg_name <other message> *0;`".
GoOnce `hActor`
  Compute a new state and send the output. This is the only way to let the logistic actor act.
SetState `hActor stateValue`
  Immediately set the current state xn to `stateValue`. Notice that this may not be the next output value, because it becomes the "previous" state xn-1 when the actor computes the next output. Valid range is [0,1].
SetCtrl `hActor ctrlValue`
  Immediately set the control variable R to `ctrlValue`.
SetOutput `hActor outputValue`
  Immediately set the output value yn to `outputValue`. This is the actual number the actor sticks into the message group.
SetScaleAndOffset `hActor scale offset`
  Set the scale and offset value of the normal output mode. Default values are 1 and 0, i.e. yn = xn.
SetNumberOfBins `hActor numBins`
  Set the number of bins of the bin output modes. Default value is 10.
SetOutputMode `hActor outputMode`
  Currently there are 4 output modes, listed in the following table:

Mode number | Description
--- | ---
0 | This is the normal mode. The output yn is calculated as: yn = scale `x` xn + offset.

1

Linear bin mode. In this mode, [0,1] is divided to equal-width bins, the number of bins is specified by `SetNumberOfBins`. The bins are numbered from 0 to `numBins`-1. The output is now calculated as yn = scale `x` bn + offset, where bn is the number of the bin in which xn falls. Setting output mode to this mode also sets scale to 1 and offset to 0, i.e. the output will be the bin number. You can use `SetScaleAndOffset` to change this afterwards.

2 | Logarithmic bin mode. The only difference between this mode and the linear bin mode is that [0,1] is divided in the logarithmic scale.
3 | Discrete sequence mode???