(Kurzweil V.A.S.T. inspired) FUN Equations.

[Kwurqx]

This is a feature request

(Kurzweil V.A.S.T. inspired) FUN Equations.

Describe the solution you'd like

Text below cited from:
http://users.skynet.be/aemit/kurz/funintro.html

What are FUNs?
FUNs are basically mathematical functions performed on one or two inputs (controllers, ENVs, LFOs etc) The output of these functions can be assigned to VAST paramaters just like any other controller.

Two things you must know:

All FUNs output values in the range -1 to +1. Controller inputs are converted to this range so while Modwheel goes from 0 to 127, as an input to a FUN it is converted to 0 to +1. Pitchwheel gives values -1 to +1.
Which brings us to the second vital bit of info. Controllers can be unipolar, i.e. only have positive values (like Modwheel) or bipolar, i.e. have positive and negative values (like Pitchwheel, some LFOs, ENVs).
It is important you understand these terms.

Some of the FUNs are very simple, others can be quite mystifying. These tutorials aim to shed some light on the FUNs. Those new to the K2000/2500/vx need not be intimidated. You can follow the text and play the programs as you go.

FUNs allow you to do a lot that you cannot do with simple controllers. They are in my opinion the most unique feature of the VAST system. The manual has a good section on FUNs. You should at least read the introduction to that chapter. As we go through the FUNs you should read the manual entries for them.

I am no expert on this stuff. I wrote this series of tutorials as a means of learning more about the FUNs myself. There will be many applications of FUNs which I have not touched on here, but I hope this gets you started.

And some "examples" (the names are just specific example KRZ programs, not relevant in this context)

FUNTUTE1 : simple additions and division
a+b, a-b, a/2+b, (a+b)/2, a/4 + b/2, (a+2b)/3, b/(1-a)
FUNTUTE2 : adds depth control to Src1, exponential controllers
ab, -ab, a*10^b
FUNTUTE3 : controlled chaos and stepped controllers
Sample B On A, Sample B On ~A, Quantize B To A
FUNTUTE4 : limiting output ranges
|a+b|, |a-b|, min(a,b), max(a,b)
FUNTUTE5 : simple switches
a AND b, a OR b, Track b While a, Track b While ~a
FUNTUTE6 : vary response times
lowpass (f=a,b), hipass (f=a,b)
FUNTUTE7 : Extra LFOs and how to modify their shapes
ramp(various types), sin(a+b), cos(a+b), tri(a+b), warp1(a,b) warp2(a,b), warp3(a,b)
FUNTUTE8 : a simple way to limit and weight control output
diode (a-b), diode (a-b +.5), diode (a-b +.25)
FUNTUTE9 : feedback equations which give unusual results
a(b-y), a(y+b), ay + b, (a+1)y +b, y +a(y+b), a |y| +b
FUNTUTE10 : making a curved response, fixing discontinuous signals, making discontinuous signals
(a+b)^2, warp4(a,b), warp8(a,b)

Describe alternatives you've considered
There aren't really any alternatives...except for using Kurzweil V.A.S.T. engine based synths.

Additional context
These mathematical calculations and/or complex or logical functions open up a world of modulation and intermodulation options. I don't know of (m)any synths that offer this. Apart from Kurzweil V.A.S.T engine based synths...

[bit-101010]

So in general FUNs are ways to combine modulations beyond addition.

A couple immediate thoughts: Arturia's Pigments has a pretty slick implementation of something similar (the "combinate" section)

Multiplying a macro control by a mod source could be a way to solve issue #857, as this would allow an automateable modulation depth.

Seems like an interesting concept, and a good implementation of this could tackle some other issues and really expand the power of Surge.

[Kwurqx]

Thanks for the swift reaction. FUN (like) modulation can be really powerfull in sounddesign. Not just for experiments or ever evolving, modulating pads and such. In a basic form I suspect it is not to complicated to implement. It is sort of a modular concept for control signals instead of audio.... Simpler forms like Envelope and LFO interactions (with or without a "mixer" concept) is a much more common but limited implemention. There aren't many sources that go further into the details and/or achievable results... Surge is one of my all time favourite synths already....keep up the good work improving and expanding it. Greetings, Kwurqx Op di 7 mei 2019 17:18 schreef Benjamin D <[email protected]>:

…

So in general FUNs are ways to combine modulations beyond addition. A couple immediate thoughts: Arturia's Pigments has a pretty slick implementation of something similar (the "combinate <https://medias.arturia.net/images/products/pigments/bas/comb.jpg>" section) Multiplying a macro control by a mod source could be a way to solve issue #857 <#857>, as this would allow an automateable modulation depth. Seems like an interesting concept, and a good implementation of this could tackle some other issues and really expand the power of Surge. — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#868 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AJO57KCIUHSSXHHSWLKM5DDPUGMUJANCNFSM4HLJXWOQ> .

[baconpaul]

So I like this class of idea a lot. Here's a natural way you could do it in surge too.

Right now the modulation architecture is you take (n) modulation sources and apply them to a target with each having a weight w_i. So val = val0 + sum( w_i * val(m_i) ) type thing. You can actually see the code that does this around like 380 of SurgeVoice.cpp

   vector<ModulationRouting>::iterator iter;
   iter = scene->modulation_voice.begin();
   while (iter != scene->modulation_voice.end())
   {
      int src_id = iter->source_id;
      int dst_id = iter->destination_id;
      float depth = iter->depth;
      if (modsources[src_id])
         localcopy[dst_id].f += depth * modsources[src_id]->output;
      iter++;
   }

Clear.

So here's one thing we could do which is not full arbitrary routing but which could solve a lot of problems. On a per-slider basis introduce a "formula". So that is when you RMB on a slider you have an "edit formula" display which shows you something like

[non-editable]
num_mods = 2
base = 0.723
m[0] = lfo_2
m[1] = key track
w[0] = 0.03
w[1] = 0.7
[editable]
output = base + m[0] * w[0] + m[1] * w[1]

Cool. Now we make it so you can edit that editable section. So you just pop up the editor and do

output = base + base * base * m[0] * m[1]

or whatever you want.

Make a little micro-language for modulation processing. It would have + - * / but would also have (probably) pow2 log2 exp log

This isn't a full arbitrary modulation architecture and it doesn't let you rewire the block diagram. For that probably use the surge-rack modules in vcvrack once I have them (a) done and (b) polyphonic. But it seems like an idea like this is something we could do in surge 1.6.1.

Thoughts?

[Kwurqx]

Paul, My C++ is a bit rusty, I guess I get the idea. You could then do some basic math, using selected available variables. This would already give a lot of options/uses. Interface-wise you might create a bit of a headache is you are going to have free texte input/parsing. One should not underestimate the power of these "basic" functions/calculations. Especially in an environment with as many modultation sources and targets.as Surge offers. E.g. check out this video with some hands on stuff. https://www.youtube.com/watch?v=oI81EvzLxHw Some other uses (from another site): NOTE: FUN's can use/incorporate other FUN's. http://dignode.com/pc3x_EN.html DEMYSTIFYING THE FUNSFUN FEATURES IN KURZWEIL SYNTHESIZERS A FUN is a controller, it controls dinamically the amount of alteration that a DSP prints to the sound, like an envelope or a LFO. A FUN receives the value of two inputs and delivers the result of a mathematical operation on them. For example, a simple addition or multiplication. Inputs may be other controllers as LFOs, knobs, the velocity at which a key has been pressed, a constant value... or even FUNs with a lower number (after all a fun is also a controller). There are countless uses. The question is: "I would like my sound did this, but there is no an speficic controller to it. It is possible with Funs?". To design an appropiate function is very useful to use the program "Visual Fun <http://www.cunka.com/forum/index.php?action=page;id=3>, from MatKat Music. RANDOM CONTROLLERS Kurzweil synthesizers generate random numbers, but you need a Fun in order to control the speed at which these values vary. An LFO create a recurrent signal at specified frequencies, the frequency can also be handled by some other controller. The sample & hold FUN take the value of the B controller only when the A controller reaches some value, so you can use an LFO to set the period in which a random value is taken: FUN1: Sample B on A A: LFO1, B:RANDV1 and the problem is solved. If you assign this FUN to the pitch at a rate of about three hertz, you can get the typical "computer of the 70's" effect, assigning a subtle value the sound is detuned and becomes more natural, with a high frequency and assigned to the amplifier you can get a thunder. Now you know how to produce sudden random values, but you can also get a smooth drift reducing the value of the FUN to a little number and, after, adding the result to the immediately preceding value: FUN2: A * B A:FUN1 B:0.10 FUN3: (A*Y)+B A:0.88 B:FUN2 This is good, for example for a wind effect. "ANALOG" ENVELOPES When a natural sound dissipates in space or in time, their power and other characteristics are not lost proportionally (linear) but logarithmically. Analog synthesizers naturally reproduce this phenomenon but the digital ones do in linear way. Some people miss more "soft" and "natural" envelopes. Logarithmic effect can be achieved by Kurzweil synthesizers by the high-pass filter function: Fun1: HIPASS (F = A, B) A is the cutoff value (0.02 to 0.05), B is the envelope to process, by example, AMPENV. The function above extracts negative values from positive functions, to correct it is necesary to use another FUN: Fun2: |A+B|, A=Fun1, B=0,5 ANOTHER FUNCTIONS TO BEND CONTROLLERS Generally, controllers that change their values linearly over the time give a sensation of mechanical precision. Controllers with curved shapes sound more organic and natural. Some suggestions: B/(1-A), A=AmpEnv, B=AmpEnv COS(A+B), A=0,50, B=AmpEnv Fun1:(A+B)^2, A=0,48, B=AmpEnv. Fun2:A+B, A=Fun1, B=-0,22 Op di 7 mei 2019 om 19:25 schreef Paul <[email protected]>:

…

So I like this class of idea a lot. Here's a natural way you could do it in surge too. Right now the modulation architecture is you take (n) modulation sources and apply them to a target with each having a weight w_i. So val = val0 + sum( w_i * val(m_i) ) type thing. You can actually see the code that does this around like 380 of SurgeVoice.cpp vector<ModulationRouting>::iterator iter; iter = scene->modulation_voice.begin(); while (iter != scene->modulation_voice.end()) { int src_id = iter->source_id; int dst_id = iter->destination_id; float depth = iter->depth; if (modsources[src_id]) localcopy[dst_id].f += depth * modsources[src_id]->output; iter++; } Clear. So here's one thing we could do which is not full arbitrary routing but which could solve a lot of problems. On a per-slider basis introduce a "formula". So that is when you RMB on a slider you have an "edit formula" display which shows you something like [non-editable] num_mods = 2 base = 0.723 m[0] = lfo_2 m[1] = key track w[0] = 0.03 w[1] = 0.7 [editable] output = base + m[0] * w[0] + m[1] * w[1] Cool. Now we make it so you can edit that editable section. So you just pop up the editor and do output = base + base * base * m[0] * m[1] or whatever you want. Make a little micro-language for modulation processing. It would have + - * / but would also have (probably) pow2 log2 exp log This isn't a full arbitrary modulation architecture and it doesn't let you rewire the block diagram. For that probably use the surge-rack modules in vcvrack once I have them (a) done and (b) polyphonic. But it seems like an idea like this is something we could do in surge 1.6.1. Thoughts? — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#868 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AJO57KHAQPVINRRVAAHZ7YLPUG3SHANCNFSM4HLJXWOQ> .

[Kwurqx]

Whoops, forgot to add a link to a major K2000 site (e.g. Darwin Grosse) A site search for FUN yields a 10 part detailed FUN Tutorial by Glen Reither. http://k2000.creativebits.net/?s=FUN Op di 7 mei 2019 om 19:25 schreef Paul <[email protected]>:

…

So I like this class of idea a lot. Here's a natural way you could do it in surge too. Right now the modulation architecture is you take (n) modulation sources and apply them to a target with each having a weight w_i. So val = val0 + sum( w_i * val(m_i) ) type thing. You can actually see the code that does this around like 380 of SurgeVoice.cpp vector<ModulationRouting>::iterator iter; iter = scene->modulation_voice.begin(); while (iter != scene->modulation_voice.end()) { int src_id = iter->source_id; int dst_id = iter->destination_id; float depth = iter->depth; if (modsources[src_id]) localcopy[dst_id].f += depth * modsources[src_id]->output; iter++; } Clear. So here's one thing we could do which is not full arbitrary routing but which could solve a lot of problems. On a per-slider basis introduce a "formula". So that is when you RMB on a slider you have an "edit formula" display which shows you something like [non-editable] num_mods = 2 base = 0.723 m[0] = lfo_2 m[1] = key track w[0] = 0.03 w[1] = 0.7 [editable] output = base + m[0] * w[0] + m[1] * w[1] Cool. Now we make it so you can edit that editable section. So you just pop up the editor and do output = base + base * base * m[0] * m[1] or whatever you want. Make a little micro-language for modulation processing. It would have + - * / but would also have (probably) pow2 log2 exp log This isn't a full arbitrary modulation architecture and it doesn't let you rewire the block diagram. For that probably use the surge-rack modules in vcvrack once I have them (a) done and (b) polyphonic. But it seems like an idea like this is something we could do in surge 1.6.1. Thoughts? — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#868 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AJO57KHAQPVINRRVAAHZ7YLPUG3SHANCNFSM4HLJXWOQ> .

[gminorcoles]

VAST-like architecture in open source would change the balance of power in synthesis that would be amazing. We should start like an institute

[mkruselj]

Like really, implementing the formula LFO mode will totally nail this feature request, and then some! We can go quite beyond VAST FUNs because we would have up to 5 arguments to play with instead of 3 (FUNs have source A, source B, and constant).

So, closing this issue as a slightly more formulated (sic!) version of it is #2048. It will really make a bunch of things similar to Kurzweil's FUNs possible.

[matkatmusic]

Hi there. I still have the source code to VisualFUN if anyone wants to see the FUNs code, as well as all of the other Modulation Source code. I was searching for 'Cunka VisualFUN" and this github issue popped up.

[baconpaul]

Is that code open source compatible licensed? If so I would very much like to see it yes!