Expression Controller

The 'expression controller can be created using the following Lisp syntax:

or:

The 'expression controller takes the following arguments:

• dimension: number of dimensions for the output controller.
• period: the time between controller updates (in synthesis seconds).
• expression_string: a text string representing the expression to be evaluated. see details, below.
• controller1, controller2, etc...: controllers to "plug-in" to the math expression.

The output controller can be optionally re-sampled using the period argument. A period of 0, as always, indicates the controller will be updated every sample.

The C-like expression string syntax is described in detail, below.

A variable number of controllers may be provided as a series of arguments, or as a list.

The expression controller is similar to the arithmetic controller, but with a richer syntax for mathematical expressions, and support for multi-dimensional controllers. It is available outside the Lisp environment, so it should be used, when and where possible, instead of a 'foreign-call controller, which is not only painfully slow, but also specific just to Modalys in the Lisp environment.

Here is a simple example of the 'expression controller's use to multiply two controllers (my-ctl1 and my-ctl2):

In this case, in(1,1) refers to the first dimension of the first controller (my-ctl1, in this example), and in(2,1) refers to the first dimension of the second controller.

The expression also lets you use variables and separate an expression into multiple subsequent statements using a semicolon. The above example could be rewritten as:

Of course the main advantage to the expression controller is it is well-suited to more complicated mathematical expressions, such as the following example which creates a Hanning window from a one-second ramp (a graph of the original ramp and window resulting from the expression controller is shown, above):

You can even get information about things in the Modalys workspace within the expression string. The following shows an example of using the expression controller to get info about the first mode of a mono-string object:

Note that the input controllers and their dimensions are numbered starting from 1 in the expression, not from 0 as they are in many other Modalys functions (such as 'dimension-mapping and 'foreign-call).

The operations in the expression string can be any of the following:

• the four standard arithmetic operators:

  • +
  • -
  • *
  • /

• exponential functions:

  • sqrt(x)
  • power(x,n)
  • exp(x)
  • log(x,n)
  • log10(x)

• trigonometric functions:

  • cos(x)
  • sin(x)
  • tan(x)
  • acos(x)
  • asin(x)
  • atan(x)
  • sinh(x)
  • cosh(x)
  • tanh(x)

• other functions:

  • abs(x)
  • min(x,y)
  • max(x,y)
  • sign(x)

• comparison:

  • <
  • >
  • <=
  • >=

• logical operators:

  • and
  • or

• conditional statements:

  • if (condition, if-true, if-false)

• constants

  • pi

• local variables (statements separated by a semicolon):

  • a = 1; b = a+1;

• controllers are indexed by <position-in-inputlist> <desired-dimension> (numbering starts from 1):

  • in(1,1)

• objects are indexed by <position-in-inputlist> (no dimension index! and numbering starts from 1)

  • in(1)

• the Modalys (get-info ... ) command can be accessed using get_info():

  • get_info('sample-rate')
  • get_info('mode-frequency', in(1), 0)

• multi-dimensional outputs are possible by separating multiple items with commas inside square brackets - each corresponds to a different dimension of the output controller

  • [ expression_1 , expression_2 ]

Some practical examples to demonstrate the syntax in a complete expression string:

• cosine of an input-controller:

  • "cos(in(1,1))"

• masking = maximum between 2 dimensions of two input-controllers:

  • "max(in(1,1),in(1,2))"

• clipping a controller to lie between -1,1:

  • "max(-1,min(1,in(1,1)))"

Also, within the Lisp environment, you could also use the Lisp (format ...) function to generate expressions for the expression controller:

(format nil "~{~[~; + ~]~[cos~;sin~](~a*in(~a,1))~}" (list-of-groups-of-4-numbers))