Home

Oneshot, smoothing, funzioni e conversioni

Indice

• Oneshot
• Smoothing
• Funzioni
• Conversioni

Quattro argomenti comuni ai diversi modi di controllare i parametri client side.

Oneshot

Inviare i valori del parametro desiderato con un trigger (valutazione del codice).

Interprete $\rightarrow$ Server attraverso la sintassi Synth.set(\arg, val).

s.boot;
s.scope;
s.plotTree;

(
SynthDef(\ksig,
              {arg freq=400, amp=0;            // parametri 
               var sig;
                   sig = SinOsc.ar(freq);
                   sig = sig * amp;
               Out.ar(0,sig)
               }
        ).add;
)

a = Synth(\ksig)

a.set(\freq, rrand(200,2000), \amp, rand(1.0)); // eseguire più volte
a.free;

I valori cambiano in modo repentino ad ogni trigger.

Questo può generare dell discontinuità del segnale (clicks e bops).

Per rimediare $\rightarrow$ smoothing o rampe.

Smoothing

Numeri (data type int o float) $\rightarrow$ segnali di controllo (o segnali audio).

Arrotondare le discontinuità di un segnale facendolo passare per un filtro a un polo (onepole).

In SuperCollider la UGen Lag.ar() che può essere indicata con due sintassi:

(
{[LFPulse.kr(1),
  Lag.kr(LFPulse.kr(1),0.2), // Come UGen
  LFPulse.kr(1).lag(0.2)     // Come metodo
]
}.plot(1)
)

Argomento $\rightarrow$ lag time in secondi ovvero è il tempo che il segnale impiega nel diminuire (o aumentare) di 60 dB seguendo una curva esponenziale.

Per semplificare all'interno delle SynthDef impieghiamo la seconda sintassi.

(
SynthDef(\ksig,
              {arg freq=400, smooth=0.02, amp=0;
               var sig, port;
                   port = freq.lag(smooth);    // portamento con tempo di lag variabile
                   sig  = SinOsc.ar(port);
                   sig  = sig * amp.lag(0.02); // ampiezza con tempo di lag fisso
               Out.ar(0,sig)
               }
          ).add;
)

a = Synth(\ksig)

a.set(\freq,rrand(200,2000),\smooth,rrand(0.02,10), \amp, rand(1.0));
a.free;

Ci sono diverse varianti con le quali possiamo modificare la curva di smooth.

(
{[LFPulse.kr(1,0.999),
  LFPulse.kr(1,0.999).varlag(0.2),
  LFPulse.kr(1,0.999).lag(0.2),
  LFPulse.kr(1,0.999).lag2(0.2),
  LFPulse.kr(1,0.999).lag3(0.2),
  LFPulse.kr(1,0.999).lagud(0.2,0.4), // u = up, d = down
  LFPulse.kr(1,0.999).lag2ud(0.2,0.4),
  LFPulse.kr(1,0.999).lag3ud(0.2,0.4)]
}.plot(1)
)

Funzioni

Tutto ciò che è racchiuso tra parentesi graffe.

Sequenza di istruzioni o operazioni che a partire da determinati input restituiscono determinati output.

I valori in uscita sono in funzione di quelli in entrata.

$$y = cos(x)$$

(
cos(0).postln; // y = 1.00000000000000
cos(1).postln; // y = 0.54030230586814
cos(2).postln; // y = -0.41614683654714
cos(3).postln; // y = -0.98999249660045
cos(4).postln; // y = -0.65364362086361
cos(5).postln; // y = 0.28366218546323
)

Visualizzazione di una funzione bidimensionale su piano cartesiano

• Variabili contengono data type.
• Funzioni contengono operazioni ricorrenti su data type.

a = 2 + 3;
a;
a.postln; 

a = {2 + 3};
a
a.value; 

I valori in input sono specificati come argomenti attraverso la parola chiave arg (ricordiamo le SynthDef?) o con una abbreviazione sintattica.

Possiamo assegnare o meno valori di default.

Quando successivamente valutiamo la funzione passiamo gli input come argomenti.

(
f = {arg a=1, b=2;         
         a / b};

g = {|luigi berenice| 
         luigi * berenice}
)

f.value;                        // Valori di default
f.value(20, 10);                // Valori come argomenti
f.value;                        // Valori di default
g.value(berenice:34, luigi: 12) // Sintassi per keyword

Al loro interno possiamo specificare variabili locali attraverso la parola chiave var.

(
f = {arg a=100, b=12;         // dichiaro argomenti (input)
     var piu,meno,diviso,per; // dichiaro variabili locali
         piu    = a + b;      // assegno le operazioni
         meno   = a - b;
         diviso = a / b;
         per    = a * b;

	["somma: "++piu,          // stampa output
	 "sottrazione: "++ meno,
	 "divisione: "++ diviso,
	 "moltiplicazione: "++ per].postln
    }                      
)

f.value(2, 3);

In SuperCollider ci sono molte AbstractFuncion (funzioni astratte) ovvero un insieme di operazioni comuni già programmate come funzioni.

Alcuni esempi.

• Unary message - un argomento.

reciprocal(0.5) // Reciproco
squared(5);     // Quadrato
ampdb(0.5);     // Conversioni, etc.
                /7 Receiver notation (alternativa)
-3.abs;         // Valore assoluto
25.sqrt;        // Radice quadrata (square root)
60.rand;        // Scelta pseudocasuale (tra 0 e n-1)
rand(60)

• Binary message - due argomenti.

3 + 2;              // Operazioni matematiche
2 > 7;              // Operazioni booleiane
round(1.2357, 0.1); // Approssimazione decimale
rrand(1.0, 23.5);   // Scelta pseudocasuale (tra min e max)
exprand(1, 800);    // Distribuzione random non lineare, etc.

• NAry message - più elementi.

13.clip(1, 10);      // Clipping
13.wrap(1, 10);      // Wrapping (modulo)
13.fold(1, 10);      // Folding (speculare)

Conversioni

Tempo

82 / 60;    // bpm  --> bps: bpm / 60.
1.3 * 60;   // bps  --> bpm: bps * 60.
82 / 60000; // bpm  --> ms:  60000. / bpm
82 / 60;    // bpm  --> s:   60. / bpm
1/2;        // frac --> ratio

Altezza

60.midicps;               // midi --> Hz
440.cpsmidi;              // Hz   --> midi
2.midiratio;              // midi --> fattore di moltiplicazione
1.6.ratiomidi;            // fatt.--> midi

440 * 1.midiratio;        // trasposizione in semitoni

Dinamica

64 / 127;       // velocity --> lineare
0.5 * 127;      // lineare  --> velocity
0.5.pow(4);     // lineare  --> quartica
0.0001.ampdb;   // lineare  --> decibel
-80.dbamp;      // decibel  --> lineare