SuperCollider 

2 clase.

Soluciones a la tarea 1

{SinOsc.ar(1360,0,0.6)*WhiteNoise.kr(0.3)}.scope
{Saw.ar(60,0.5)*SinOsc.kr(780,0,0.34)}.scope
{SinOsc.ar(1000,0,0.5)*SinOsc.kr(240,0,0.5,0.5)}.scope   // Esto esta más alla del conocimiento que tienes, no cuenta para calificación.
{BrownNoise.ar(0.3)*SinOsc.kr(3,0,0.9)}.scope
{Pulse.ar(10,0.1,0.5)*LFTri.kr(100,0.5)}.scope
{Saw.ar(30,0.3)*WhiteNoise.kr(0.6)}.scope
{LFTri.ar(30,0.1,0.3)*WhiteNoise.kr(0.6)*SinOsc.kr(10,0,0.4,0.6)}.scope
{Saw.ar(302,0.3)*SinOsc.kr(10.6,0,0.6)*WhiteNoise.kr(0.710)}.scope
{SinOsc.ar(100,0,0.5)*SinOsc.kr(2,0,0.5,0.5)}.scope
{Saw.ar(12000,0.4)*WhiteNoise.kr(0.3)*Saw.ar(1200,0.4)*SinOsc.kr(40,0,0.6)}.scope
{(PinkNoise.ar(0.2)*WhiteNoise.kr(0.2))+Saw.ar(40,0.041)}.scope
{(Pulse.ar(40,0.01,0.3)*SinOsc.kr(30,0,0.4,0.5)*WhiteNoise.kr(0.8))+Saw.ar(10,0.4)}.scope
{((WhiteNoise.ar(0.5)*Dust.kr(10))+PinkNoise.ar(0.9))*SinOsc.kr(100,0,0.4,0.5)}.scope
{Saw.ar(30,0.3)+Saw.ar(70,0.3)}.scope
{((Saw.ar(460,0.3)+Pulse.ar(462,0.4,0.3))*Dust.kr(10))+LFTri.ar(42,0.1,0.2)}.scope
{SinOsc.ar(14000,0,0.9)*Dust.kr(300)}.scope
{LFTri.ar(70,0,0.3)*Dust.kr(100)}.scope
{SinOsc.ar(45,0,0.3)+SinOsc.ar(40,0,0.3)+SinOsc.ar(100,0,0.2)+SinOsc.ar(50,0,0.3)}.scope
{LFTri.ar(30,0,0.5)*SinOsc.kr(1000,0,0.7)}.scope
{Saw.ar(130,0.2)+SinOsc.ar(100,0,0.3)+WhiteNoise.ar(0.031)}.scope

Filtros

Un filtro es un sistema que, dependiendo de algunos parámetros, realiza un proceso de discriminación de una señal de entrada obteniendo variaciones en su salida. Notar que en todos los casos de los filtros que vamos a ver el primer argumento es la señal que se desea filtar y el segundo argumento es la frecuencia de corte. La frecuencia de corte en los filtros HPF y LPF tiene un significado ligeramente distinto que en el filtro BPF. Los tres filtros que veremos a continuación pueden funcionar tanto con .ar como con .kr. La condición al usarlos es que la señal que se quiera filtrar tenga el mismo rate que el filtro.

 
HPF	- High Pass Filter -- Filtro Pasa Altas 
Es aquel que permite el paso de frecuencias desde una frecuencia determinada hacia arriba, sin que exista un límite superior especificado. Esta frecuencia determinada es la frecuencia de corte. Por ejemplo, si determinamos que sea 700 Hz la frecuencia de corte dejaremos pasar todas las frecuencias mas altas que 700 Hz.

Argumentos: entrada, frecuencia de corte, multiplicación y adición.

Sintaxis : HPF.ar(entrada, frecuencia de corte, multiplicación, adición)

	entrada : La señal que queremos filtrar. Tiene que tener .ar.

	frecuencia de corte : Frecuencia en Hertz a partir de la cual se permitirá el paso de frecuencias mas altas.

	multiplicación : Número por el cual multiplicamos la señal del filtro. Generalmente se identifica con el 
	 			  volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
	 			  1 dejando la señal sin alterar.

	adición : Número que se le suma a la señal del filtro. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin 			alterar.

LPF	- Low Pass Filter-- Filtro Pasa Bajas.
Es aquel que permite el paso de  frecuencias bajas, desde la frecuencia 0 hasta una frecuencia determinada. Esta frecuencia determinada es la frecuencia de corte. Por ejemplo, si determinamos que sea 200 Hz la frecuencia de corte dejaremos pasar todas las frecuencias mas bajas que 200 Hz. Recordemos que no hay frecuencias menores a 0 Hz.

Argumentos: entrada, frecuencia de corte, multiplicación y adición.

Sintaxis : LPF.ar(entrada, frecuencia de corte, multiplicación, adición)

	entrada : La señal que queremos filtrar. Tiene que tener .ar.

	frecuencia de corte : Frecuencia en Hertz a partir de la cual se permitirá el paso de frecuencias mas bajas.

	multiplicación : Número por el cual multiplicamos la señal del filtro. Generalmente se identifica con el 
	 			  volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
	 			  1 dejando la señal sin alterar.

	adición : Número que se le suma a la señal del filtro. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin 			alterar.

BPF	- Band Pass Filter -- Filtro Pasa Banda
Es aquel que perimte el paso de frecuencias contenidas dentro de un determinado rango o banda, comprendido entre una frecuencia  inferior y otra superior. La distancia entre estas frecuencias determina el ancho de banda. La frecuencia que está en el centro de esta distancia es la frecuencia de corte. Por ejemplo, si determinamos que sea 1000 Hz la frecuencia de corte y 200 Hz el ancho de banda podemos saber cual es el rango de frecuencias que dejaremos pasar usando la siguiente fórmula:

cota inferior = frecuencia de corte - ancho de banda/2

cota superior = frecuencia de corte + ancho de banda/2 

La cota superior es la frecuencia límite superior y la cota inferior es la frecuencia límite inferior.

Si sabemos cuáles son las cotas inferior y superior que queremos entonces podemos obtener el ancho de banda y la frecuencia de corte con la siguiente fórmula:

ancho de banda = cota superior - cota inferior

frecuencia de corte = cota inferior + ancho de banda/2

BPF no es el único filtro que utiliza un ancho de banda. En este filtro y en todos los demás de este tipo el ancho de banda no se puede escribir directamente como un argumento. En vez de ancho de banda estos filtros tienen como argumento rq. 

q =  frecuencia de corte / ancho de banda. 
Por lo tanto el reciproco de q = 1/q = ancho de banda / frecuencia de corte = rq

Argumentos : entrada, frecuencia de corte, rq, multiplicación y adición.

Sintaxis : BPF.ar(entrada, frecuencia de corte, rq, multiplicación, adición)

	entrada : La señal que queremos filtrar. 

	frecuencia de corte : Frecuencia en Hertz que determina el centro de la banda de nuestro filtro.
	
	rq : recíproco de q, es decir, ancho de banda / frecuencia de corte.

	multiplicación : Número por el cual multiplicamos la señal del filtro. Generalmente se identifica con el 
	 			  volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
	 			  1 dejando la señal sin alterar.

	adición : Número que se le suma a la señal del filtro. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin 			alterar.

Algunos ejemplos. 

{ HPF.ar(WhiteNoise.ar(0.1), 7030)}.scope // Aqui un WhiteNoise (Ruido Blanco) es filtrado por un filtro pasa altas dejando pasar frecuencias arriba de los 7030 Hz

{ LPF.ar(WhiteNoise.ar(0.1), 7030)}.scope // Aqui lo contrario: pasan las frecuencias debajo de los 7030 Hz

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 700/7000)}.scope // El tercer argumento del filtro pasa banda es el reciproco de Q.

En este ejemplo tenemos ancho de banda=700 y frecuencia de corte=7000. O sea, 700/7000=0.1 Por lo tanto rq=0.1
A veces es mas rapido escribir el numero decimal que el quebrado. Veamos entonces como queda sustituyendo del ejemplo anterior:

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 0.1)}.scope

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 1)}.scope // Aqui tenemos otro valor para el rq. 

Si tenemos que 1 = ancho de banda / frecuencia de corte = rq, entonces sabemos que ancho de banda=frecuencia de corte = rq.
Y si frecuencia de corte = 7030,
entonces rq = 7030 / 7030.
Por lo tanto sabemos que la linea de codigo anterior se puede escribir tambien de la siguiente forma:

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 7030/7030)}.scope

Hay señales que se prestan a ser filtradas y otras que no. Por ejemplo, una senoide (SinOsc) no se presta a ser filtrada por que solo contiene una frecuencia. No existe nada mas arriba ni mas abajo de esa frecuencia para ser retirado. Los ruidos, que son un conjunto complejo se frecuencias son los que dan resultados mas notables al ser filtrados. 

Control con el Mouse

Una forma de controlar los argumentos de los UGens en SuperCollider es através de las Clases MouseY, MouseX y MouseButton Estas clases son UGens de control por lo que trabajan con el mensaje kr. Los argumentos principales de los UGens MouseY y MouseX son el valor mínimo y el valor máximo que queremos obtener al mover nuestro mouse. En MouseButton los argumentos son el valor cuando el mouse no está apretado y cuando si. 

En SuperCollider para Windows se utiliza JMouseY, JMouseX y JMouseButton. Al final de tu linea de código agregar 

JMouseBase.makeGUI

separado por;

Ejemplos:

MouseX.kr(0,100) // obtengo numeros desde 0 cuando el mouse esta hasta la izquierda hasta 100 cuando el mouse esta  en el extremo derecho.

MouseY.kr(0,100) // obtengo numeros desde 0 cuando el mouse esta hasta arriba hasta 100 cuando el mouse esta  hasta abajo.

Notar que en Y el maximo es abajo y el minimo arriba. En X el maximo es a la derecha y el minimo a la izquierda.

MouseButton.kr(0,1) // Cuando no esta apretado tengo el valor 0 y cuando si el valor 1.

{SinOsc.ar(MouseY.kr(1000,100))}.scope  // Puedo hacer un barrido desde la frecuencia 100 cuando el mouse esta abajo hasta 1000 cuando el mouse esta hasta arriba

{SinOsc.ar(400,0,MouseX.kr(0,1))}.scope  // Amplitud (volumen) 0 cuando el mouse esta en el extremo izquierdo hasta 1 cuando el mouse esta en el extremo derecho

{SinOsc.ar(MouseX.kr(1000,100),0,MouseY.kr(0,1))}.scope // Mezclando los dos ejemplos anteriores con MouseY y MouseX

{Pulse.ar(MouseY.kr(10000,20),MouseX.kr(0.001,0.5),MouseButton.kr(0,1))}.scope

Los mismos ejemplos de filtros usando la clase MouseY y MouseX

{ HPF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,100))}.scope

{ LPF.ar(WhiteNoise.ar(0.1), MouseX.kr(10000,100))}.scope

{ BPF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,100), 0.05)}.scope
{ BPF.ar(WhiteNoise.ar(0.5), 130, MouseX.kr(0.05,1.5))}.scope

{ BRF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,100), 1)}.scope
{ BRF.ar(WhiteNoise.ar(0.1), 7030, MouseX.kr(0.05,1.5))}.scope

Los mismos ejemplos pero para SuperCollider en Windows

{SinOsc.ar(JMouseY.kr(1000,100))}.jscope;JMouseBase.makeGUI
{SinOsc.ar(400,0,MouseX.kr(0,1))}.jscope;JMouseBase.makeGUI
{SinOsc.ar(MouseX.kr(1000,100),0,MouseY.kr(0,1))}.jscope;JMouseBase.makeGUI
{Pulse.ar(MouseY.kr(10000,20),MouseX.kr(0.001,0.5),MouseButton.kr(0,1))}.Jscope;JMouseBase.makeGUI

Los mismos ejemplos de filtros usando la clase MouseY y MouseX

{ HPF.ar(WhiteNoise.ar(0.1), JMouseY.kr(10000,100))}.jscope;JMouseBase.makeGUI
{ LPF.ar(WhiteNoise.ar(0.1), JMouseX.kr(10000,100))}.jscope;JMouseBase.makeGUI
{ BPF.ar(WhiteNoise.ar(0.1), JMouseY.kr(10000,100), 0.05)}.jscope;JMouseBase.makeGUI
{ BPF.ar(WhiteNoise.ar(0.5), 130, JMouseX.kr(0.05,1.5))}.jscope;JMouseBase.makeGUI
{ BRF.ar(WhiteNoise.ar(0.1), JMouseY.kr(10000,100), 1)}.jscope;JMouseBase.makeGUI
{ BRF.ar(WhiteNoise.ar(0.1), 7030, JMouseX.kr(0.05,1.5))}.jscope;JMouseBase.makeGUI

Tarea 2

/* 1  */ {_______.ar(BrownNoise.ar(0.5),160)}.scope
/* 2  */ {HPF.ar(_______.ar(10,0.75)*WhiteNoise.ar(1),10000)}.scope
/* 3  */ {Saw.ar(10,0.75)*___.ar(WhiteNoise.ar(1),10000)}.scope
/* 4  */ {_______.ar(Saw.ar(2,0.6),3000,100/3000)+BPF.ar(_______.ar(3,0.4),_______,50/500)}.scope
/* 5  */ {LFTri.ar(1,0,1)*LPF.ar(_______.ar(30,0.1,1),1000)}.scope
/* 6  */ {Pulse.ar(117,_______.kr(0.5,0.01),0.5)}.scope
/* 7  */ {_______.ar(MouseX.kr(60,800),0,0.6)}.scope
/* 8  */ {_______.ar(_______.ar(100),MouseY.kr(15000,160),60/MouseY.kr(15000,160))}.scope
/* 9  */ {Pulse.ar(_______.kr(5,20))_______(SinOsc.ar(10000,0,0.6)_______SinOsc.ar(90,0,0.6))}.scope
/* 10 */ {Pulse.ar(MouseY.kr(110,90),_______,0.5)*_______.ar(100,0.1,0.5)}.scope