Influx | SuperCollider 3.13.0 Help

Description

Influx (and its named cousin, Idef) explores the idea of performing with running processes by means of influence on process parameters rather than direct control. This is a MetaControl approach. It maps input values to output values by allowing every input param to influence any output param by a given weight.

InfluxBase (or also IBdef) are the base classes for all Influx variants
InfluxMix (or also IMdef) mix several sources into one influx;
InfluxSpread (or also ISdef) spread one Influx's settings to multiple destinations

Typical Usage Scenarios

FAN IN/FAN OUT

One typical use would be with sound processes or patterns with too many input parameters: Rather than mapping one control directly to each param, one can entangle rather few control parameters to influence a big bundle of process control inputs. While this will not access to the full possibility space, it can reduce time to find interesting areas in the space (which one then might want to store)

DIS/ENTANGLE

One can also use the same param names for input and output, starting with neutral weights like [0,0,1,0] where each param only influences its same-named output. Then one can introduce "entanglement" between params by adding small random deviations to the weights.

RELATIVE - playing around a known preset

One can use a known location in the param space (e.g. a stored good preset) as a starting point, and use Influx to play relative to the preset. Here, zooming allows very subtle explorations of shadings within a known good zone.

First example:// make an influx - fan-in, fan-out a = Influx([\x, \y], [\a, \b, \c,\d, \e, \f, \g, \h], (x: 0.5, y: 0.1)); b = InfluxWGui(a); // randomize to a maximum bipolar value a.rand(0.5).postw; // blend toward a given array of values a.blend([1,0.1, 0.1, 0.5]).postw; a.blend([1,0.1, 0.1], 0.9).postw; // make a control interface for it // x and y of the 2d slider control x and y by default c = InfluxKtlGui(a); // see the in and out values d = InfluxIOWGui(a); a.set(\x, 0.0, \y, 0.2).postw; // set to a specific place a.set(\x, 1.0.rand2, \y, 1.0.rand2).postw; // jump randomly a.set(\x, 0.0, \y, 0.0); // set to center // shortcut to set to center, useful with offsetsFromProxy: a.center;

Longer example follows below!

See also Examples folder:(Quark("Influx").localPath +/+ "Examples").openOS; // e.g. this file on output vale remapping: (Quark("Influx").localPath +/+ "Examples/Remap_Influx_by_envelope.scd").openOS;

Class Methods

.new

make a new Influx

Arguments:

ins	names for the inputs to use
outs	names for outputs to use
vals	an optional dictionary of values for the input names as keys
weights	an optional list of weights (of shape inputs x outputs) that determine how much influence which ins exert on which outs.

Instance Methods

Instance Variables

.inNames

the input names

.outNames

the output names

.inValDict

the dict of input values

.outValDict

the dict of output values

.action

a FuncChain, where actions can be put that run when new output values are calculated. This is used for attaching e.g. Ndefs to be played with Influx.

.shape

.smallDim

.bigDim

shape is the shape of the weights, [inNames.size, outNames.size] smallDim is the smaller of the two, bigDim the greater.

.presets

a dict of named weights presets used for disentangling. Can also be a place to put user presets of weights.

.inScaler

a scaler for the input values - zooms into a smaller range around the center setting. (see examples)

.outOffsets

by default, influences start from the center. To explore a parameter space near a given setting, one can make a bipolarized version of that setting, and set the outOffsets to it. See examples.

Instance Methods

.postv

.postw

.postp

pretty-post input and output values, weights, and weights presets

.plot

plot the weights arrays with an InfluxPlot. a.plot;

.set

set input values of Influx

Arguments:

... keyValPairs

key1, val1, ... keyN, valN

.rand

create random weights up to +- maxval given.

.blend

blend weights with other array by given factor. other array values will wrap as required by weights shape.

.calcOutVals

calculate new output values and do the action(s).

.makePresets

make some default presets (diagonal etc.)

.setwPre

set weights to preset of the given name.

.entangle

add more entanglement between params; drift is the amount of entanglement from 0.0 to 1.0

.disentangle

disentangle in the direction of a preset

Arguments:

blend	by how much to disentangle
presetName	name of the weights preset to disentangle towards, default is diagL

.attachMethod

attach an object - typically a JITLib proxy like Ndef, Tdef - to set its params from the Influx outputs.

Arguments:

object	the object
funcName	a name to use in the influx action, which is an MFunc.
paramNames	paramNames to set - if none given, gets them from the object.
specs	specs to use for mapping. If none are given, the object will be asked via `object.getSpec`.

Examples

// EXAMPLES
// make an influx - fan-out 2 params to 8
a = Influx([\x, \y], [\a, \b, \c,\d, \e, \f, \g, \h], (x: 0.5, y: 0.1));

// or give the number of ins and outs:
a = Influx(2, 8);
// or use a named Influx, an Idef:
a = Idef(\a, 2, 8);

// make plot/edit views for weights:
d = InfluxIOWGui(a); d.skipjack.dt = 0.05;

///// interactive gui example
// recommended for direct use:
InfluxKtlGui(a);

//// more tests by code - check that new values appear
a.set(\x, 1.0, \y, 0);
a.center;    // go to center values
a.set(\x, 1.0.rand2, \y, 1.0.rand2);

// add an action to perform when outvals change
a.action.add(\test, { |influx|
    "post outValDict:".postln;
    influx.outValDict.sortedKeysValuesDo { |key, val|
        [key, val.round(0.001)].postln;
    };
});

a.set(\x, 1.0.rand2, \y, 1.0.rand2);
a.set(\x, 1.0.rand2, \y, 1.0.rand2);
a.set(\x, 1.0.rand2, \y, 1.0.rand2);

// remove again by name:
a.action.remove(\test);

// try playing a boring sound with too many parameters
// note that .addSpec requires JITLibExtensions quark
(
Ndef(\a).addSpec(\intv, [-24, 24]);
Ndef(\a).addSpec(\timescale, [0.01, 10, \exp]);
Ndef(\a).addSpec(\curve, [-10, 10]);
Ndef(\a).addSpec(\ffreq, \freq);
Ndef(\a).addSpec(\loopnode, [0, 12]);

Ndef(\a).addSpec(\dens, [10, 1000]);
Ndef(\a).addSpec(\resfreq, \freq);
Ndef(\a).addSpec(\ringtime, [0.01, 1, \exp]);

Ndef(\a, { |freq=250, intv=19, timescale=1, curve=0, loopnode=0, dens = 10, resfreq = 500, ringtime = 0.01|
    var n = 15;
    var env = EnvGen.kr(
        Env({ 1.0.rand2 }!(n+1), {1.0.rand}!n, curve, releaseNode: n-1, loopNode: loopnode.min(n-3)),
        timeScale: timescale);
    var pitch = (env * [1, 0.33, -1] * intv).midiratio * freq;
    var form = Formant.ar(pitch, pitch.rotate(1) * 1.6, pitch.rotate(2) * 2.6);

var dusty = Ringz.ar(Dust.ar(dens!3), resfreq * LFNoise0.kr([3, 5, 7], 0.5, 1), ringtime) * ((dens ** -0.5) * (ringtime ** -0.3)) ;
    Splay.ar(form * dusty);

}).play(vol: 0.25);
Ndef(\a).gui.moveTo(0, 50).skipjack.dt_(0.05);
);
Ndef(\a).play;

// connect the influx action to the Ndef
a.attachMapped(Ndef(\a));

// (this actually does:)
/// a.attachMapped(Ndef(\a), Ndef(\a).key, Ndef(\a).controlKeys);

// now play with the influx gui for a while ...

// and remove it again when done:
a.detach(\a);

// EXPERIMENTS WITH SETTINGS:

// set ndef to a special setting, here a strange whistler effect:
Ndef('a').set('dens', 535.47, 'timescale', 0.331, 'loopnode', 6.23, 'curve', 4.75, 'freq', 12299.63, 'intv', -16.18, 'resfreq', 2581.33, 'ringtime', 0.238);

// and explore playing RELATIVE to this setting:

// puts the current ndef setting in the center at 0@0:
a.offsetsFromProxy(Ndef(\a));
// put the controller there
a.center;
// rather wide range, setting is at center
a.inScaler = 1;
a.inScaler = 0.5; // smaller range, zooming in
a.inScaler = 0.25; // even smaller

// PLAY RELATIVE TO A PRESET

// Next, try playing this with NdefPreset.
// try finding interesting, contrasting settings,
// storing them, morphing between them;
// then try explore the areas around a preset by zooming in
// and creating offsets...
// this requires the JITLibExtensions Quark.
(
n = NdefPreset(Ndef(\a));
g = NdefPresetGui(NdefPreset(\a), 12);
g.skipjack.dt = 0.1;
)

// make some rand presets
n.setRand(0.5);
n.addSet(\noisy);
n.setRand(0.5);
n.addSet(\crackly);

(
// or add a few settings from earlier experiments
NdefPreset(\a).addSettings([
('noisy' -> [ [ 'freq', 9355.48 ], [ 'intv', -11.95 ], [ 'timescale', 0.285 ], [ 'curve', 3.938 ], [ 'loopnode', 3.052 ], [ 'dens', 534.251 ], [ 'resfreq', 859.160 ], [ 'ringtime', 0.0134 ] ]),
('crickety' -> [ [ 'freq', 32.366 ], [ 'intv', -5.187 ], [ 'timescale', 0.0954 ], [ 'curve', 0.2156 ], [ 'loopnode', 4.712 ], [ 'dens', 636.7 ], [ 'resfreq', 6358.147 ], [ 'ringtime', 0.964 ] ]),

('dense' -> [ [ 'freq', 690.505 ], [ 'intv', -21.576 ], [ 'timescale', 0.327 ], [ 'curve', 9.646 ], [ 'loopnode', 1.2 ], [ 'dens', 529.79 ], [ 'resfreq', 1646.71 ], [ 'ringtime', 0.0539 ] ]),
('otto' -> [ [ 'freq', 454.81 ], [ 'intv', -2.666 ], [ 'timescale', 0.8055 ], [ 'curve', 0.7688 ], [ 'loopnode', 8.2 ], [ 'dens', 510.5 ], [ 'resfreq', 305.044 ], [ 'ringtime', 0.04298 ] ]),
('whistle2' -> [ [ 'freq', 32.567 ], [ 'intv', -20.467 ], [ 'timescale', 0.0672 ], [ 'curve', -0.9438 ], [ 'loopnode', 6.89 ], [ 'dens', 518.313 ], [ 'resfreq', 1582.355 ], [ 'ringtime', 0.0639 ] ]),
('whistle3' -> [ [ 'freq', 194.16 ], [ 'intv', 6.367 ], [ 'timescale', 0.1955 ], [ 'curve', -9.31 ], [ 'loopnode', 6.619 ], [ 'dens', 631.79 ], [ 'resfreq', 9158.27 ], [ 'ringtime', 0.0202 ] ])
]);
)

// set the offsets from preset: now center values [0,0] will play the preset.
a.offsetsFromPreset(n, \crickety);

// set the scaler smaller to zoom in to a smaller neighborhood of the preset
a.inScaler = 0.5;

n.getSet(\whistle2);
NdefPreset(\a).settings.printcsAll;

n.getSetNames.choose

// choose a random preset
a.offsetsFromPreset(n, n.getSetNames.choose);

// Influx can process its output values:
// as linear sums can exceed [-1, 1], params can stick there.
// addProc allows adding processing filters to keep the
// outvals within [-1, 1] borders in different ways.
// e.g. use tanh to compress when approaching borders,
// and never quite reach them
a.addProc(\base, { |val| val.tanh });
// fold2: bounce back at borders
a.addProc(\base, { |val| val.fold2(1.0) });

// addProc base processes basic outVals,
// one can also process individual attached outputs:
// remove general outVals proc
a.addProc(\base, nil);

// add one for attached Ndef(\a) - note difference
// between outVals on influx gui and params on NdefGui
a.addProc(\a, { |val| val.tanh });
// boost values before tanh to push toward extremes
a.addProc(\a, { |val| (val * 1.5).tanh });

// or try folding
a.addProc(\a, { |val| val.fold2(1.0) });

// take offsets from a random preset from above:
// outvals are processed after adding offsets.
// note that nonlinear processing will distort the values
// of the stored preset somewhat.
// (this could be reverse-calculated for the filter)
a.offsetsFromPreset(n, n.getSetNames.choose);
a.addProc(\a, { |val| (val * 1.5).tanh });

a.dump

// example for making a control window by hand for customization
(
w = Window("Influx control", Rect(0, 630, 300, 200)).front;
w.layout = VLayout(
    HLayout(
        VLayout(
            StaticText(w, 190@20).string_("Change  weights:"),
            Button(w, 190@20).states_([["set to diagonal"]])
            .action_({ a.setwPre(\diagL); }),
            Button(w, 190@20).states_([["disentangle"]])
            .action_({ a.disentangle(0.3); }),
            Button(w, 190@20).states_([["entangle"]])
            .action_({ a.entangle(0.3); }),
            Button(w, 190@20).states_([["RANDOM"]])
            .action_({  a.rand(1.0); })
        ),
        VLayout(
            StaticText(w, 190@20).string_("Change inputs:"),
            Slider2D(w, 190@190)
            .action_({|sl| a.set(\x, sl.x * 2 - 1, \y, sl.y * 2 - 1); })
        )
    )
);

v = Window("Influx2 state", Rect(0, 300, 300, 300)).front;
v.addFlowLayout;

StaticText(v, 290@20).string_("Influx values:");

[a.inValDict, a.outValDict].collect { |dict, i|
    var eg = ParamGui(nil, [4, 8][i], v, 280@100, options: [\name]);
    eg.name_(["ins", "outs"][i]);
    dict.keysDo { |key| eg.specs.put(key, \bipolar) };
    eg.object_(dict);
    eg.zone.enabled_(false);
    eg.skipjack.dt = 0.1;
}
);

helpfile source: HelpSource/Classes/Influx.schelp
link::Influx/Classes/Influx::

InfluxExtension

Description

Typical Usage Scenarios

Class Methods

.new

Arguments:

Instance Methods

Instance Variables

.inNames

.outNames

.inValDict

.outValDict

.action

.shape

.smallDim

.bigDim

.presets

.inScaler

.outOffsets

Instance Methods

.postv

.postw

.postp

.plot

.set

Arguments:

.rand

.blend

.calcOutVals

.makePresets

.setwPre

.entangle

.disentangle

Arguments:

.attachMethod

Arguments:

Examples

Influx
Extension