The materials prepared for the workshop are based on the program *FScape* that I have been developing since many years, and which is now embedded in the computer music environment *Mellite*. *Mellite* is an open source application that we will be using during the workshop to explore these algorithms.

Link to Mellite : this is the front page with links to some tutorials and download and installation instruction (read them carefully). Direct downloads are available from https://archive.org/download/Mellite - use the "universal" zip for all platforms. Extract it, the application is in the 'bin' directory. Check the main page for additional requirements (Java 8, SuperCollider). Also download the FScape-modules.zip separately, it contains a couple of programs that we might be using.

Link Source Code of workshop examples

Prepared programs:

Apart from some standard FScape modules, we use custom programs made for the workshop and available as a downloadable Mellite workspace.

Two other programs that may come handy:

- FScape (v1 classic): More processing modules
- Eisenkraut: Sound file editor with drag-and-drop from Mellite

(Again you can use the universal-zip downloads)

**Materials Hanns Holger Rutz**

Motion study. Differential phase correlation between successive frames of a moving image. Rendered with *FScape*, using *cosh* amplitude mapping.

Plot study. The classical Logistic Map rendered with *FScape*, using its PenImage UGen. The recursive nature of the formula poses an interesting challenges to its implementation, as there are currently no means to produce single sample feedback.

[hhr 190404]

David was asking if it was possible to render something like the logistic map in FScape. At first I thought that the problem might be the block-size and recursive graph, but thinking about it, one anyway quits the iteration at a maximum number of steps, so we can just "expand" the recursion a number of times. We'd need a complement for ScanImage; now investigating if we could thus use interpolation as well, and then we'd have alpha components (interpolation weights) and something like Porter Duff composite could come handy. Since the easiest is to handle all channels independently (through multi-channel expansion), we might add the constraint that Ad (alpha component of destination) is constant 1.0, and will also not be updated. Then the 12 Porter Duff rules essentially reduce to 6. But if we allow other binary operators to stand in place of the usual addition in the chroma calculation, we can "interpret" the formerly redundant 6 rules by flipping the operands, which would make sense for non-commutative binary operators (e.g. subtraction or division).

[hhr 190404]

Logistic map would look something like this:

// logistic function

def fun: (GE, GE) => GE =

(x, r) => r * x * (1 - x)

val xa = 2.9

val xb = 4.0

val w = 240

val h = 500

val maxIt = 200

val y0 = 0.0

val y1 = 1.0

val itH = maxIt/2

val hm = h - 1

val i = ArithmSeq(0, step = 1, length = w)

val r = xa + (xb - xa) * i / (w - 1)

var x = 0.5: GE

for (j <- 0 until maxIt) {

x = fun(x, r) // recursion

???

// if (j > itH && x >= y0 && x <= y1) {

// val xs = x.linLin(y0, y1, 0, 1)

// wr.setSample(i, ((1 - xs) * hm).toInt, 0, 0)

// }

}