Pink Noise

///////////////////////////////// PINK NOISE /////////////////////////////////

s.boot;

s.meter;
s.scope;
s.plotTree;


// Only use when necessary. It isn't always needed.

s.reboot;
s.quit;


///////////////////// Things To Know Before Running Code /////////////////////

/*

All my original SC documents are in the "dracula" color.
To find or change this, go To SuperCollider ––> Preferences ––> Editor ––> Font & Colors.
––> Select under Color, dracula.

Arguments in Synths are represented with a backslash, "\", in green under the "dracula" color font. Values presented with these arguments can be changed. Only remember to NEVER cross 0, when using an exponential method like "exprand."

Arguments also precede a colon ":", as seen in a list of a UGen following a variable, "var."
Example: sig = PlayBuf.ar(2, buf, rate, startPos: spos);

Argument and variable names can be changed to your liking.

Please be careful with volume output. Always have SuperCollider run through headphones. If you're unsure what the output will be, keep headphones away, with your main volume all the way down. Check your level meter and Stethoscope for visual cues. If everything looks safe (e.g. level meter is NOT in the red), proceed.

You can always execute a hard stop with Command Period.

*/



////////////////////////////// Pink Noise Function ///////////////////////////////

{PinkNoise.ar(mul: 0.2, add: 0.0)}.play; // mono

// Press Cmd Period to stop the synth instantaneously. Or Windows Period.

// The argument names followed by a ":" isn't necessary.
// Arguments in the UGen array must be in order (e.g. mul, then add)
// If you do not write in the arguments, it outputs the default values (which you can bring up with keying Shift+Cmd+Space, or Shift+Windows+Space, for Windows).

// You can convert the mono signal to a stereo signal, using "!2."

{PinkNoise.ar(0.2)!2}.play; // stereo

// Evaluate the following code to see the new array:

PinkNoise.ar(0.2)!2

// Compare it with the previous function, without the "!2."

PinkNoise.ar(0.2)


(
~pink = {
    arg mul=0.2;
    var sig;
    sig = PinkNoise.ar(mul)!2;
};
)

x = ~pink.play;
x.release(3); // release the synth over 3 seconds


x = ~pink.play;
x.set(\mul, 0.05);
x.release(1);


// OCEAN WAVE

// Add the control variable, SinOsc, to create the effect of ocean waves.
// Note, using the ".kr" method is less CPU expensive than using ".ar".
// The ".ar" method is typically used for an audio signal (e.g., output we can hear), because its smoothness is greater than that produced by ".kr."
// NOTE: We will not need smoothness for this kind of noise generation.


(
~pinkNoise = {
    arg freq=1/4, mul=0.5; // 1/4 translates into 1 wave every 4 seconds
    var sig, mod;
    mod = SinOsc.kr(freq: freq, phase: 0, mul: mul, add: 0);
    sig = PinkNoise.ar(mul)!2;
    sig = sig * mod;
};
)

x = ~pinkNoise.play;
x.release(8);

// It's a good sound, but let's compare different phase values.

// phase: 0
{SinOsc.ar(phase: 0)}.plot;
{SinOsc.kr(phase: 0)}.plot;


// Compare the smoothness of the two rate methods.

(
{[SinOsc.ar(phase: 0), SinOsc.kr(phase: 0)]}.plot;
)

// phase: 2pi is the same as phase: 0.
// See below.

(
{[SinOsc.ar(phase: 0), SinOsc.ar(phase: 2pi)]}.plot;
)

// phase: pi
{SinOsc.ar(phase: pi)}.plot;
{SinOsc.kr(phase: pi)}.plot;

// Compare the smoothness of the two rate methods.

(
{[SinOsc.ar(phase: pi), SinOsc.kr(phase: pi)]}.plot;
)

// We want the contrary motion, the rising to +1 in the bipolar cycle.

{SinOsc.ar(phase: 3pi/2)}.plot;
{SinOsc.kr(phase: 3pi/2)}.plot;

// Compare the smoothness of the two rate methods.

(
{[SinOsc.ar(phase: 3pi/2), SinOsc.kr(phase: 3pi/2)]}.plot;
)

// Compare 0 and 3pi/2 for phase (using ".ar"):

(
{[SinOsc.ar(phase: 0), SinOsc.ar(phase: 3pi/2)]}.plot;
)

// 3pi/2 on the bottom panel is the motion I'm looking for. But it still starts at -1 before crossing 0. Reduce the output by half, by giving "mul" the value of 0.5.

// For the record, we'll keep this SinOsc with an audio rate.

{SinOsc.ar(phase: 3pi/2, mul: 0.5)}.plot;

// Now give the "add" argument the value, 0.5, so that the intial sample will begin on 0.

{SinOsc.ar(phase: 3pi/2, mul: 0.5, add: 0.5)}.plot;

// With this, we should have our "ocean wave" start at 0, rising to 1, and falling to 0, in the duration provided (e.g. using the "freq" argument).

// Note, pi/2 is the opposite motion. Compare the two different phases.

{SinOsc.ar(phase: pi/2, mul: 0.5, add: 0.5)}.plot;
{SinOsc.ar(phase: 3pi/2, mul: 0.5, add: 0.5)}.plot;


(
{[SinOsc.ar(phase: pi/2, mul: 0.5, add: 0.5), SinOsc.ar(phase: 3pi/2, mul: 0.5, add: 0.5)]}.plot;
)


(
~pinkNoise = {
    arg freq=0.25, amp=0.2;
    // 0.25 (or 1/4) is translated into 1 wave every 4 seconds.
    // Notice, I'm leaving for now the "mul" argument value fixed at 0.5.
    // The argument name for amplitude is now "amp." This is for our signal, PinkNoise.
    var sig, mod;
    mod = SinOsc.ar(freq: freq, phase: 3pi/2, mul: 0.5, add: 0.5);
    sig = PinkNoise.ar(amp)!2;
    sig = sig * mod;
};
)

x = ~pinkNoise.play;
x.release(8);


// Condensed

FreqScope.new; // To reference the frequency spectrum.

(
~pinkNoise = {
    arg freq=0.25, amp=0.2;
    var sig, mod;
    mod = SinOsc.ar(freq: freq, phase: 3pi/2, mul: 0.5, add: 0.5);
    sig = PinkNoise.ar(amp)!2; // Go between PinkNoise and BrownNoise.
    sig = sig * mod;
};
)

x = ~pinkNoise.play;
x.release(8);


// Here's the Function with the different phase values.
// Level meter is a good visual indicator to see where in the cycle it starts, (e.g. s.meter;)

(
~pinkNoise = {
    arg freq=0.25, amp=0.2;
    var sig, mod;
    mod = SinOsc.ar(freq: freq, phase: pi/2, mul: 0.5, add: 0.5);
    sig = PinkNoise.ar(amp)!2; // Go between PinkNoise and BrownNoise.
    sig = sig * mod;
};
)

// Remember, pi/2 is the opposite cyclic motion of 3pi/2.

x = ~pinkNoise.play;
x.release(8);

(
~pinkNoise = {
    arg freq=0.25, amp=0.2;
    var sig, mod;
    mod = SinOsc.ar(freq: freq, phase: 0, mul: 0.5, add: 0.5);
    sig = PinkNoise.ar(amp)!2; // Go between PinkNoise and BrownNoise.
    sig = sig * mod;
};
)

x = ~pinkNoise.play;
x.release(8);

(
~pinkNoise = {
    arg freq=0.25, amp=0.2;
    var sig, mod;
    mod = SinOsc.ar(freq: freq, phase: pi, mul: 0.5, add: 0.5);
    sig = PinkNoise.ar(amp)!2; // Go between PinkNoise and BrownNoise.
    sig = sig * mod;
};
)

x = ~pinkNoise.play;
x.release(8);