Chaos in Faust

Moet 'm maar 'ns herlezen, zeker 30 jaar geleden ofzo dat ik het las. Maar vaag herinner ik me nog wel dat het een aardig boek was.
 
Ben op de helft: een heel interessant boek, niet veel wiskunde (daarvoor zijn andere boeken) maar des te meer over de achtergronden en geschiedenis van de chaos theorie. Het boek is smullen voor wie graag leest over wetenschappelijke ontwikkelingen.

Heb het boek nu uit, en dat is mij voor de geschiedenis van de chaos theorie mooi genoeg. Volgende leesboek is meer op de praktijk gericht:

 
Bij het lezen van het boek wordt mij wel duidelijk dat er al gigantisch veel simpele chaotische circuits bestaan. Ergens wel jammer want het avontuurlijke om daarmee aan de slag te gaan gaat er zo wel vanaf. Aan de andere kant is het een heel mooi boek, met veel nuttige tips en info over chaos en het bouwen van elektronische circuits. Ik heb er geen spijt van dat ik het gekocht heb.
 
Ergens wel jammer want het avontuurlijke om daarmee aan de slag te gaan gaat er zo wel vanaf.

Er zijn nog wel wat uitdagingen, als je zoiets wil gebruiken voor geluidssynthese. Het rauwe, onbewerkte signaal van zo'n circuit is meestal niet echt aangenaam om naar te luisteren. Om het maar zacht uit te drukken. Met wat effecten erover is het al beter, maar dat is een tamelijk oppervlakkige bewerking. Het zou eigenlijk als basismateriaal moeten dienen voor de synthese van goede, bruikbare klanken, daar is nog wel wat te winnen om geschikte methoden te bedenken die dat doen.
 
Da's waar, en daar heb ik ook al wat ideeën voor. ;)

Ook ben ik er nog steeds niet uit of mijn riedeltjes Faust progje nu wel of niet chaotisch is. Ik lees daar tegenstrijdige zaken over. Zie een vereenvoudigde versie hieronder:

Code:
declare name "Yes-or-No-Chaos";

import("maths.lib");
import("filters.lib");

start  = 0.01*button("start");

A = _ , start :> _*-1 : _ ;
B = _ : atan : pole(1) : pole(1) : _*1645333507 : _ ;
C = A~B ;

safe(x) = atan((10^-11)*x)/3;

process = C : safe <: _,_ ;

Met de 32-bit VST-plugin versie in de bijlage.
 

Attachments

  • YesorNoChaos.dll.zip
    85,1 KB · Bekeken: 150
Het zou een digitaal artefact kunnen zijn, in die zin dat de verspringende tonen ontstaan door afrondingsfouten in de digitale implementatie. En vergelijkbare circuits met OpAmp zijn lastig te bouwen want door de vereiste extreme versterkingen en verzwakkingen pik je sowieso al allerlei storingen op.

Als het echt chaotisch is mag het patroon zich ook nooit herhalen, maar hoe weet je dat zonder het tot in de eeuwigheid af te luisteren...?
 
Dit stukje Faust code vormt de kern van de zaak:

Code:
A = _ , _*-1 : _ ;
B = _ : atan : pole(1) : pole(1) : _*1645333507 : _ ;
C = A~B ;

De vraag is nu even welke differentiaalvergelijking daar precies gesimuleerd wordt.

a.png
b.png
c.png


(Het startblokje is behalve voor het opstarten niet interessant.)
 
Laatst gewijzigd:
Om nog weer op je vraag terug te komen, ik zou het echte chaos noemen als de oplossing van de in het Faust progje gesimuleerde differentiaalvergelijking in wiskundige zin chaotisch is. In dat laatste geval weten we dat we niet slechts met een digitaal artefact te doen hebben.
 
Uit het blokschema lezen we voor de gesimuleerde DV af dat:

x(t) = A(B(x(t))
x(t) = -B(x(t))
x(t) = -1645333507 * integrator( integrator( arctan(x(t)) ) )

Nu nog even de vraag hoe die gesimuleerde integrator operatie er in Faust precies uitziet.
 
In de Faust Libraries lezen we:

integrator.png


Natuurkundig gesproken zou er voor iedere n-de sample een stukje van bij benadering x(n)*T (met T de sample tijd) aan de integraal moeten worden toegevoegd. Er geldt (bij benadering) dus:

[imath] \int_0^t f(\tau) \, \mathrm{d} \tau = \mathrm{T} \cdot \mathrm{integrator}(f(t) ) [/imath]

En voor een sample rate SR:

[imath] \mathrm{integrator}(f(t) ) = \mathrm{SR} \cdot \int_0^t f(\tau) \, \mathrm{d} \tau [/imath]


(Of dat laatste in de praktijk ook klopt vraag ik mij af want ik heb daar wel vaker mee zitten hannesen.)
 
Code:
declare name "Riedeltest";

import("maths.lib");
import("filters.lib");

start  = 0.01*button("start");

frequentie = hslider("frequentie",440,20,10000,0.01);
omega = 2*PI*frequentie;

A = _*-1*omega^2,start :> _ ;
B = _ : integrator/SR : integrator/SR : _ ;
C = A~B ;

safe(x) = atan(x)/3;

process = C : safe <: _,_ ;

Later verder...
 
Even de vaststelling van de gesimuleerde DV afronden. Onderstaande blokjes horen bij het Riedertest progje:

a.png
b.png


c.png
 
Afgezien van de startpuls "start" en er even van uitgaande dat [imath] \mathrm{integrator}(f(t) ) = \mathrm{SR} \cdot \int_0^t f(\tau) \, \mathrm{d} \tau [/imath] hebben we dus:

[imath] - \int_0^t \int_0^t x(\tau) \, \mathrm{d} \tau \mathrm{d} \tau \cdot \omega^2 = x(t) [/imath]

[imath] - x(t) \cdot \omega^2 = \ddot{x}(t) [/imath]

[imath] \ddot{x}(t) +\omega^2 \cdot x(t) = 0 [/imath]

Dit is de differentiaalvergelijking voor een harmonische oscillator met hoekfrequentie [imath] \omega [/imath].

Door nu voor het Riedeltest progje in de online Faust IDE wat met de horizontale "frequentie" slider te spelen en de daar ingestelde testfrequentie te vergelijken met de daadwerkelijk gemeten frequentie in de output analyser zien we dat die twee frequenties (ongeveer) overeen stemmen. Dat resultaat beschouw ik als afdoende bevestiging dat de eerder gevonden relatie [imath] \mathrm{integrator}(f(t) ) = \mathrm{SR} \cdot \int_0^t f(\tau) \, \mathrm{d} \tau [/imath] inderdaad correct is.
 
Back
Top