moving examples to top dir

Ge Wang committed 9 years ago

Commit 35ca2f61 parent fd011ef486 files · +-44 −-44Browse files

Showing the changes to examples/basic (48 of 486 files). Show all

Unified · Split

48 files

examples/basic/adc.ck +11 −0
examples/basic/adsr.ck +24 −0
examples/basic/alarm.ck +31 −0
examples/basic/args.ck +11 −0
examples/basic/bar.ck +17 −0
examples/basic/blit.ck +23 −0
examples/basic/blit2.ck +30 −0
examples/basic/chirp.ck +47 −0
examples/basic/chirp2.ck +81 −0
examples/basic/comb.ck +22 −0
examples/basic/curly++.ck +30 −0
examples/basic/curly.ck +27 −0
examples/basic/delay.ck +9 −0
examples/basic/demo0.ck +12 −0
examples/basic/demo1.ck +14 −0
examples/basic/demo2.ck +65 −0
examples/basic/demo3.ck +27 −0
examples/basic/echo.ck +15 −0
examples/basic/envelope.ck +20 −0
examples/basic/fm.ck +22 −0
examples/basic/fm2.ck +17 −0
examples/basic/fm3.ck +16 −0
examples/basic/foo.ck +17 −0
examples/basic/foo2.ck +38 −0
examples/basic/func.ck +36 −0
examples/basic/i-robot.ck +17 −0
examples/basic/imp.ck +18 −0
examples/basic/infnan.ck +16 −0
examples/basic/larry++.ck +40 −0
examples/basic/larry.ck +27 −0
examples/basic/lfo.ck +13 −0
examples/basic/moe++.ck +42 −0
examples/basic/moe.ck +27 −0
examples/basic/rec-auto-stereo.ck +29 −0
examples/basic/rec-auto.ck +28 −0
examples/basic/rec.ck +23 −0
examples/basic/ring.ck +26 −0
examples/basic/sndbuf.ck +17 −0
examples/basic/step.ck +13 −0
examples/basic/tick.ck +9 −0
examples/basic/tick2.ck +12 −0
examples/basic/unchuck.ck +41 −0
examples/basic/valueat.ck +24 −0
examples/basic/whirl.ck +16 −0
examples/basic/whole.ck +30 −0
examples/basic/wind.ck +20 −0
examples/basic/wind2.ck +37 −0
examples/basic/zerox.ck +14 −0

@@ -0,0 +1,11 @@
	1	+// mic-in to audio out
	2	+
	3	+// the patch
	4	+adc => dac;
	5	+
	6	+// infinite time-loop
	7	+while( true )
	8	+{
	9	+ // advance time
	10	+ 100::ms => now;
	11	+}

examples/basic/adsr.ck+24−0

@@ -0,0 +1,24 @@
	1	+// an ADSR envelope
	2	+// (also see envelope.ck)
	3	+SinOsc s => ADSR e => dac;
	4	+
	5	+// set a, d, s, and r
	6	+e.set( 10::ms, 8::ms, .5, 500::ms );
	7	+// set gain
	8	+.5 => s.gain;
	9	+
	10	+// infinite time-loop
	11	+while( true )
	12	+{
	13	+ // choose freq
	14	+ Math.random2( 20, 120 ) => Std.mtof => s.freq;
	15	+
	16	+ // key on - start attack
	17	+ e.keyOn();
	18	+ // advance time by 800 ms
	19	+ 500::ms => now;
	20	+ // key off - start release
	21	+ e.keyOff();
	22	+ // advance time by 800 ms
	23	+ 800::ms => now;
	24	+}

examples/basic/alarm.ck+31−0

@@ -0,0 +1,31 @@
	1	+// how long
	2	+2::hour => dur T;
	3	+// frequency
	4	+880 => float f;
	5	+
	6	+// remember
	7	+now => time start;
	8	+now + T => time later;
	9	+
	10	+// wait
	11	+while( now < later )
	12	+{
	13	+ <<< (T - (now - start)) / second, "left..." >>>;
	14	+ 1::second => now;
	15	+}
	16	+
	17	+// patch
	18	+SinOsc s => JCRev r => dac;
	19	+.025 => r.mix;
	20	+f => s.freq;
	21	+
	22	+// infinite while loop
	23	+while( true )
	24	+{
	25	+ // go
	26	+ 1.0 => s.gain;
	27	+ 300::ms => now;
	28	+ // stop
	29	+ 0.0 => s.gain;
	30	+ 300::ms => now;
	31	+}

examples/basic/args.ck+11−0

@@ -0,0 +1,11 @@
	1	+// shows getting command line arguments
	2	+// (example run: chuck args:1:2:foo)
	3	+
	4	+// print number of args
	5	+<<< "number of arguments:", me.args() >>>;
	6	+
	7	+// print each
	8	+for( int i; i < me.args(); i++ )
	9	+{
	10	+ <<< " ", me.arg(i) >>>;
	11	+}

examples/basic/bar.ck+17−0

@@ -0,0 +1,17 @@
	1	+// point of attack for random otf demo
	2	+
	3	+SinOsc s => dac;
	4	+.2 => s.gain;
	5	+
	6	+// an array: add stuff
	7	+[ 0 ] @=> int hi[];
	8	+
	9	+while( true )
	10	+{
	11	+ // change parameters here
	12	+ Std.mtof( 45 + Math.random2(0,0) * 12 +
	13	+ hi[Math.random2(0,hi.size()-1)] ) => s.freq;
	14	+
	15	+ // different rate
	16	+ 200::ms => now;
	17	+}

examples/basic/blit.ck+23−0

@@ -0,0 +1,23 @@
	1	+// patch
	2	+Blit s => JCRev r => dac;
	3	+.5 => s.gain;
	4	+.05 => r.mix;
	5	+
	6	+// an array
	7	+[ 0, 2, 4, 7, 9, 11 ] @=> int hi[];
	8	+// <<< hi.size() >>>;
	9	+// <<< hi[0], hi[1], hi[2], hi[3], hi[4], hi[5] >>>;
	10	+
	11	+// infinite time loop
	12	+while( true )
	13	+{
	14	+ // frequency
	15	+ Std.mtof( 33 + Math.random2(0,3) * 12 +
	16	+ hi[Math.random2(0,hi.size()-1)] ) => s.freq;
	17	+
	18	+ // harmonics
	19	+ Math.random2( 1, 5 ) => s.harmonics;
	20	+
	21	+ // advance time
	22	+ 120::ms => now;
	23	+}

examples/basic/blit2.ck+30−0

@@ -0,0 +1,30 @@
	1	+// patch
	2	+Blit s => ADSR e => JCRev r => dac;
	3	+.5 => s.gain;
	4	+.05 => r.mix;
	5	+
	6	+// set adsr
	7	+e.set( 5::ms, 3::ms, .5, 5::ms );
	8	+
	9	+// an array
	10	+[ 0, 2, 4, 7, 9, 11 ] @=> int hi[];
	11	+
	12	+// infinite time loop
	13	+while( true )
	14	+{
	15	+ // frequency
	16	+ Std.mtof( 33 + Math.random2(0,3) * 12 +
	17	+ hi[Math.random2(0,hi.size()-1)] ) => s.freq;
	18	+
	19	+ // harmonics
	20	+ Math.random2( 1, 5 ) => s.harmonics;
	21	+
	22	+ // key on
	23	+ e.keyOn();
	24	+ // advance time
	25	+ 120::ms => now;
	26	+ // key off
	27	+ e.keyOff();
	28	+ // advance time
	29	+ 5::ms => now;
	30	+}

examples/basic/chirp.ck+47−0

@@ -0,0 +1,47 @@
	1	+// po-tweet!
	2	+
	3	+// patch
	4	+SinOsc s => dac;
	5	+// gain
	6	+.4 => s.gain;
	7	+
	8	+// call chirp
	9	+chirp( 127, 20, 1::second );
	10	+
	11	+// call chirp (with tinc)
	12	+chirp( 20, 120, 1.5::second, 100::ms );
	13	+
	14	+// chirp function
	15	+fun void chirp( float src, float target, dur duration )
	16	+{
	17	+ chirp( src, target, duration, 1::ms );
	18	+}
	19	+
	20	+// chirp function (with tinc)
	21	+fun void chirp( float src, float target, dur duration, dur tinc )
	22	+{
	23	+ // initialize freq
	24	+ src => float freq;
	25	+ // find the number of steps
	26	+ duration / tinc => float steps;
	27	+ // find the inc
	28	+ ( target - src ) / steps => float inc;
	29	+ // counter
	30	+ float count;
	31	+
	32	+ // do the actual work over time
	33	+ while( count < steps )
	34	+ {
	35	+ // increment the freq
	36	+ freq + inc => freq;
	37	+ // count
	38	+ 1 +=> count;
	39	+
	40	+ // set the freq
	41	+ Std.mtof( freq ) => s.freq;
	42	+
	43	+ // advance time
	44	+ tinc => now;
	45	+ }
	46	+}
	47	+

examples/basic/chirp2.ck+81−0

@@ -0,0 +1,81 @@
	1	+// more chirping...
	2	+
	3	+// patch with envelope and pan
	4	+SinOsc s => Envelope e => Pan2 p => dac;
	5	+// gain
	6	+.5 => s.gain;
	7	+
	8	+// pan hard left
	9	+-1 => p.pan;
	10	+// call chirp
	11	+chirp( 127, 20, 1::second );
	12	+
	13	+// wait for envelope to go down
	14	+10::ms => now;
	15	+// pan hard right
	16	+1 => p.pan;
	17	+// call chirp
	18	+chirp( 20, 120, 1::second, 100::ms );
	19	+
	20	+// wait a second
	21	+1::second => now;
	22	+
	23	+// randomize pan
	24	+Math.random2f( -1, 1 ) => p.pan;
	25	+// call chirp
	26	+chirp( 30, 110, .5::second );
	27	+
	28	+// wait for envelope to go down
	29	+10::ms => now;
	30	+// pan
	31	+Math.random2f( -1, 1 ) => p.pan;
	32	+// call chirp
	33	+chirp( 110, 30, 1::second, 100::ms );
	34	+
	35	+// wait a second
	36	+1::second => now;
	37	+
	38	+
	39	+// chirp function
	40	+fun void chirp( float src, float target, dur duration )
	41	+{
	42	+ // just call the other one with default tinc
	43	+ chirp( src, target, duration, 1::ms );
	44	+}
	45	+
	46	+
	47	+// chirp function (with tinc)
	48	+fun void chirp( float src, float target, dur duration, dur tinc )
	49	+{
	50	+ // initialize freq
	51	+ src => float freq;
	52	+ // find the number of steps
	53	+ duration / tinc => float steps;
	54	+ // find the inc
	55	+ ( target - src ) / steps => float inc;
	56	+ // counter
	57	+ float count;
	58	+ // set env
	59	+ .01 * duration / second => e.time;
	60	+ // open env
	61	+ 1 => e.keyOn;
	62	+
	63	+ // do the actual work over time
	64	+ while( count < steps )
	65	+ {
	66	+ // increment the freq
	67	+ freq + inc => freq;
	68	+ // count
	69	+ 1 +=> count;
	70	+
	71	+ // set the freq
	72	+ Std.mtof( freq ) => s.freq;
	73	+
	74	+ // advance time
	75	+ tinc => now;
	76	+ }
	77	+
	78	+ // close env
	79	+ 1 => e.keyOff;
	80	+}
	81	+

examples/basic/comb.ck+22−0

@@ -0,0 +1,22 @@
	1	+// a simple comb filter
	2	+// Ge Wang (gewang@cs.princeton.edu)
	3	+
	4	+// feedforward
	5	+Impulse imp => Gain out => dac;
	6	+// feedback
	7	+out => Delay delay => out;
	8	+
	9	+// our radius
	10	+.99999 => float R;
	11	+// our delay order
	12	+500 => float L;
	13	+// set delay
	14	+L::samp => delay.delay;
	15	+// set dissipation factor
	16	+Math.pow( R, L ) => delay.gain;
	17	+
	18	+// fire impulse
	19	+1 => imp.next;
	20	+
	21	+// advance time
	22	+(Math.log(.0001) / Math.log(R))::samp => now;

examples/basic/curly++.ck+30−0

@@ -0,0 +1,30 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe++ larry++ curly++
	3	+
	4	+// impulse to filter to dac
	5	+SndBuf i => NRev r => dac;
	6	+
	7	+// load glottal ooo
	8	+"special:glot_ooo" => i.read;
	9	+// play
	10	+//5.0 => i.rate;
	11	+.1 => r.mix;
	12	+
	13	+0.0 => float v;
	14	+
	15	+// infinite time-loop
	16	+while( true )
	17	+{
	18	+ // set the current sample/impulse
	19	+ 0 => i.pos;
	20	+ // control gain
	21	+ Math.cos(v) => i.gain;
	22	+ // increment v
	23	+ .05 +=> v;
	24	+ // advance time
	25	+ 81.0::ms => now;
	26	+}
	27	+
	28	+
	29	+
	30	+

examples/basic/curly.ck+27−0

@@ -0,0 +1,27 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe larry curly
	3	+
	4	+// impulse to filter to dac
	5	+Impulse i => BiQuad f => dac;
	6	+// set the filter's pole radius
	7	+.99 => f.prad;
	8	+// set equal gain zeros
	9	+1 => f.eqzs;
	10	+// initialize float variable
	11	+0.0 => float v;
	12	+// set filter gain
	13	+.5 => f.gain;
	14	+
	15	+// infinite time-loop
	16	+while( true )
	17	+{
	18	+ // set the current sample/impulse
	19	+ 1.0 => i.next;
	20	+ // sweep the filter resonant frequency
	21	+ Std.fabs(Math.sin(v)) * 800.0 => f.pfreq;
	22	+ // increment v
	23	+ v + .1 => v;
	24	+ // advance time
	25	+ 101::ms => now;
	26	+}
	27	+

examples/basic/delay.ck+9−0

@@ -0,0 +1,9 @@
	1	+// patch
	2	+adc => DelayL delay => dac;
	3	+
	4	+// set delay parameters
	5	+.75::second => delay.max => delay.delay;
	6	+
	7	+// infinite time loop
	8	+while( true ) 1::second => now;
	9	+

examples/basic/demo0.ck+12−0

@@ -0,0 +1,12 @@
	1	+// demo0.ck
	2	+// basic demo showing time and duration
	3	+
	4	+5::second + now => time later;
	5	+
	6	+while( now < later )
	7	+{
	8	+ <<<now>>>;
	9	+ 1::second => now;
	10	+}
	11	+
	12	+<<<now>>>;

examples/basic/demo1.ck+14−0

@@ -0,0 +1,14 @@
	1	+// demo1.ck
	2	+// candidate for most trivial demo
	3	+
	4	+0 => int a => int t;
	5	+1 => int b;
	6	+15 => int c;
	7	+
	8	+while( c > 0 )
	9	+{
	10	+ a + b => t;
	11	+ b => a;
	12	+ <<<t => b>>>;
	13	+ c - 1 => c;
	14	+}

examples/basic/demo2.ck+65−0

@@ -0,0 +1,65 @@
	1	+// demo2.ck
	2	+// really lame!
	3	+
	4	+// set the global gain
	5	+.1 => dac.gain;
	6	+
	7	+/*
	8	+// connect
	9	+SinOsc a => dac;
	10	+110.0 => a.freq;
	11	+1::second => now;
	12	+SinOsc b => dac;
	13	+220.0 => b.freq;
	14	+1::second => now;
	15	+SinOsc c => dac;
	16	+440.0 => c.freq;
	17	+1::second => now;
	18	+SinOsc d => dac;
	19	+880.0 => d.freq;
	20	+1::second => now;
	21	+SinOsc e => dac;
	22	+1760.0 => e.freq;
	23	+1::second => now;
	24	+*/
	25	+
	26	+SinOsc oscarray[5];
	27	+for(0 => int i; i<5; i++) {
	28	+
	29	+ oscarray[i] => dac;
	30	+ Math.pow(2, i) * 110.0 => oscarray[i].freq;
	31	+
	32	+}
	33	+
	34	+/*
	35	+// disconnect
	36	+a =< dac;
	37	+1::second => now;
	38	+b =< dac;
	39	+1::second => now;
	40	+c =< dac;
	41	+1::second => now;
	42	+d =< dac;
	43	+1::second => now;
	44	+e =< dac;
	45	+1::second => now;
	46	+*/
	47	+
	48	+for(0 => int i; i<5; i++) {
	49	+
	50	+ oscarray[i] =< dac;
	51	+ 1::second => now;
	52	+
	53	+}
	54	+
	55	+
	56	+
	57	+
	58	+
	59	+
	60	+
	61	+
	62	+
	63	+
	64	+
	65	+

examples/basic/demo3.ck+27−0

@@ -0,0 +1,27 @@
	1	+// demo3.ck
	2	+// super lame
	3	+
	4	+// global gain
	5	+Gain g => dac;
	6	+// set gain
	7	+.5 => g.gain;
	8	+
	9	+110.0 => float freq;
	10	+6 => int x;
	11	+
	12	+// loop
	13	+while( x > 0 )
	14	+{
	15	+ // connect to gain
	16	+ SinOsc s => g;
	17	+ // change frequency
	18	+ freq => s.freq;
	19	+ freq * 2.0 => freq;
	20	+ // decrement x
	21	+ 1 -=> x;
	22	+
	23	+ // advance time by 1 second
	24	+ 1::second => now;
	25	+ // disconnect the sinosc
	26	+ s =< g;
	27	+}

examples/basic/echo.ck+15−0

@@ -0,0 +1,15 @@
	1	+// feedforward
	2	+adc => Gain g => dac;
	3	+// feedback
	4	+g => Gain feedback => DelayL delay => g;
	5	+
	6	+// set delay parameters
	7	+.75::second => delay.max => delay.delay;
	8	+// set feedback
	9	+.5 => feedback.gain;
	10	+// set effects mix
	11	+.75 => delay.gain;
	12	+
	13	+// infinite time loop
	14	+while( true ) 1::second => now;
	15	+

examples/basic/envelope.ck+20−0

@@ -0,0 +1,20 @@
	1	+// run white noise through envelope
	2	+Noise n => Envelope e => dac;
	3	+
	4	+// infinite time-loop
	5	+while( true )
	6	+{
	7	+ // random choose rise/fall time
	8	+ Math.random2f(10,500)::ms => dur t => e.duration;
	9	+ // print
	10	+ <<< "rise/fall:", t/ms, "ms" >>>;
	11	+
	12	+ // key on - start attack
	13	+ e.keyOn();
	14	+ // advance time by 800 ms
	15	+ 800::ms => now;
	16	+ // key off - start release
	17	+ e.keyOff();
	18	+ // advance time by 800 ms
	19	+ 800::ms => now;
	20	+}

examples/basic/fm.ck+22−0

@@ -0,0 +1,22 @@
	1	+// FM synthesis by hand
	2	+
	3	+// carrier
	4	+SinOsc c => dac;
	5	+// modulator
	6	+SinOsc m => blackhole;
	7	+
	8	+// carrier frequency
	9	+220 => float cf;
	10	+// modulator frequency
	11	+550 => float mf => m.freq;
	12	+// index of modulation
	13	+200 => float index;
	14	+
	15	+// time-loop
	16	+while( true )
	17	+{
	18	+ // modulate
	19	+ cf + (index * m.last()) => c.freq;
	20	+ // advance time by 1 samp
	21	+ 1::samp => now;
	22	+}

examples/basic/fm2.ck+17−0

@@ -0,0 +1,17 @@
	1	+// basic FM synthesis using SinOsc (2 => .sync; also see fm3.ck)
	2	+
	3	+// modulator to carrier
	4	+SinOsc m => SinOsc c => dac;
	5	+
	6	+// carrier frequency
	7	+440 => c.freq;
	8	+// modulator frequency
	9	+110 => m.freq;
	10	+// index of modulation
	11	+300 => m.gain;
	12	+
	13	+// phase modulation is FM synthesis (sync is 2)
	14	+2 => c.sync;
	15	+
	16	+// time-loop
	17	+while( true ) 1::second => now;

examples/basic/fm3.ck+16−0

@@ -0,0 +1,16 @@
	1	+// FM synthesis (using Step instead of .sync == 2; see fm2.ck)
	2	+
	3	+// modulator to carrier
	4	+SinOsc m => SinOsc c => dac;
	5	+// step function, add to modulator output
	6	+Step step => c;
	7	+
	8	+// carrier frequency
	9	+440 => step.next;
	10	+// modulator frequency
	11	+110 => m.freq;
	12	+// index of modulation
	13	+300 => m.gain;
	14	+
	15	+// time-loop
	16	+while( true ) 1::second => now;

examples/basic/foo.ck+17−0

@@ -0,0 +1,17 @@
	1	+// hello everyone.
	2	+// a chuck is born...
	3	+// its first words:
	4	+
	5	+SinOsc s => JCRev r => dac;
	6	+.2 => s.gain;
	7	+.1 => r.mix;
	8	+
	9	+// an array
	10	+[ 0, 2, 4, 7, 9, 11 ] @=> int hi[];
	11	+
	12	+while( true )
	13	+{
	14	+ Std.mtof( 45 + Math.random2(0,3) * 12 +
	15	+ hi[Math.random2(0,hi.size()-1)] ) => s.freq;
	16	+ 100::ms => now;
	17	+}

examples/basic/foo2.ck+38−0

@@ -0,0 +1,38 @@
	1	+// bandlimited ugens (Blit, BlitSaw, BlitSquare)
	2	+Blit s => Pan2 p;
	3	+p.left => JCRev r1 => dac.left;
	4	+p.right => JCRev r2 => dac.right;
	5	+
	6	+// initial settings
	7	+.5 => s.gain;
	8	+.1 => r1.mix;
	9	+.1 => r2.mix;
	10	+
	11	+// an array
	12	+[ 0, 2, 4, 7, 9, 11 ] @=> int hi[];
	13	+
	14	+// set the harmonic
	15	+4 => s.harmonics;
	16	+
	17	+// spork the pan control
	18	+spork ~ dopan();
	19	+
	20	+// infinite time loop
	21	+while( true )
	22	+{
	23	+ Std.mtof( 33 + Math.random2(0,3) * 12 +
	24	+ hi[Math.random2(0,hi.size()-1)] ) => s.freq;
	25	+ 120::ms => now;
	26	+}
	27	+
	28	+// pan control
	29	+fun void dopan()
	30	+{
	31	+ float t;
	32	+ while( true )
	33	+ {
	34	+ .7 * Math.sin(t) => p.pan;
	35	+ .005 +=> t;
	36	+ 10::ms => now;
	37	+ }
	38	+}

examples/basic/func.ck+36−0

@@ -0,0 +1,36 @@
	1	+8 => int a;
	2	+
	3	+fun int abs( int v )
	4	+{
	5	+ if( v < 0 ) return -v;
	6	+ return v;
	7	+}
	8	+
	9	+fun void args( int y, int b )
	10	+{
	11	+ 4 => a;
	12	+ <<<b>>>;
	13	+}
	14	+
	15	+fun float sum( float a, float b )
	16	+{
	17	+ return a + b;
	18	+}
	19	+
	20	+fun void go( int a )
	21	+{
	22	+ <<<abs(a)>>>;
	23	+ if( a == 0 )
	24	+ return;
	25	+
	26	+ go( abs(a)-1 );
	27	+}
	28	+
	29	+int i;
	30	+for( 0 => i; i < 10; i + 1 => i )
	31	+ go( 1000 );
	32	+<<<abs(-1)>>>;
	33	+args( 1, 2 );
	34	+<<<sum( 1.0, 2.0 )>>>;
	35	+<<<a>>>;
	36	+

examples/basic/i-robot.ck+17−0

@@ -0,0 +1,17 @@
	1	+// take me to your leader (talk into the mic)
	2	+// gewang, prc
	3	+
	4	+// our patch - feedforward part
	5	+adc => Gain g => DelayL d => dac;
	6	+adc => Gain g2 => dac;
	7	+// feedback
	8	+d => Gain g3 => d;
	9	+
	10	+// set parameters
	11	+15::ms => d.delay;
	12	+0.05 => g.gain;
	13	+0.05 => g2.gain;
	14	+0.95 => g3.gain;
	15	+
	16	+// time loop
	17	+while( true ) 100::ms => now;

examples/basic/imp.ck+18−0

@@ -0,0 +1,18 @@
	1	+// impulse generator is cool...
	2	+// this demo is not
	3	+
	4	+// connect impulse generator
	5	+Impulse i => dac;
	6	+.5 => i.gain;
	7	+
	8	+// emit impulse every so often
	9	+2000 => int a;
	10	+while( 1 )
	11	+{
	12	+ // set the next sample
	13	+ 1.0 => i.next;
	14	+
	15	+ // advance time
	16	+ a::samp => now;
	17	+ a - 8 => a; if( a <= 0 ) 2000 => a;
	18	+}

examples/basic/infnan.ck+16−0

@@ -0,0 +1,16 @@
	1	+// big number
	2	+1000000000000000000000000000.0 => float n;
	3	+// overflow it
	4	+repeat( 20 ) n *=> n;
	5	+// test it
	6	+<<< Math.isinf( n ) >>>;
	7	+// bye sanity
	8	+0 *=> n;
	9	+// test it
	10	+<<< Math.isnan( n ) >>>;
	11	+
	12	+// more
	13	+<<< 1.0 / 0.0 => Math.isinf >>>;
	14	+<<< 0.0 / 0.0 => Math.isnan >>>;
	15	+<<< Math.INFINITY, -Math.INFINITY >>>;
	16	+<<< Math.INFINITY => Math.isinf >>>;

examples/basic/larry++.ck+40−0

@@ -0,0 +1,40 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe++ larry++ curly++
	3	+
	4	+// impulse to filter to dac
	5	+SndBuf i => BiQuad f => Gain g => JCRev r => dac;
	6	+// second formant
	7	+i => BiQuad f2 => g;
	8	+// third formant
	9	+i => BiQuad f3 => g;
	10	+
	11	+// set the filter's pole radius
	12	+0.800 => f.prad; .995 => f2.prad; .995 => f3.prad;
	13	+// set equal gain zeroes
	14	+1 => f.eqzs; 1 => f2.eqzs; 1 => f3.eqzs;
	15	+// initialize float variable
	16	+0.0 => float v => float v2;
	17	+// set filter gain
	18	+.1 => f.gain; .1 => f2.gain; .01 => f3.gain;
	19	+0.05 => r.mix;
	20	+// load glottal pop
	21	+"special:glot_pop" => i.read;
	22	+// play
	23	+1.0 => i.rate;
	24	+
	25	+// infinite time-loop
	26	+while( true )
	27	+{
	28	+ // set the current sample/impulse
	29	+ 0 => i.pos;
	30	+ // sweep the filter resonant frequency
	31	+ 250.0 + Math.sin(v100.0)20.0 => v2 => f.pfreq;
	32	+ 2290.0 + Math.sin(v200.0)50.0 => f2.pfreq;
	33	+ 3010.0 + Math.sin(v300.0)80.0 => f3.pfreq;
	34	+ // increment v
	35	+ v + .05 => v;
	36	+ // gain
	37	+ 0.2 + Math.sin(v)*.1 => g.gain;
	38	+ // advance time
	39	+ (1000.0 + Math.random2f(-100.0, 100.0))::ms => now;
	40	+}

examples/basic/larry.ck+27−0

@@ -0,0 +1,27 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe larry curly
	3	+
	4	+// impulse to filter to dac
	5	+Impulse i => BiQuad f => dac;
	6	+// set the filter's pole radius
	7	+.99 => f.prad;
	8	+// set equal gain zeros
	9	+1 => f.eqzs;
	10	+// initialize float variable
	11	+0.0 => float v;
	12	+// set filter gain
	13	+.5 => f.gain;
	14	+
	15	+// infinite time-loop
	16	+while( true )
	17	+{
	18	+ // set the current sample/impulse
	19	+ 1.0 => i.next;
	20	+ // sweep the filter resonant frequency
	21	+ Std.fabs(Math.sin(v)) * 4000.0 => f.pfreq;
	22	+ // increment v
	23	+ v + .1 => v;
	24	+ // advance time
	25	+ 99::ms => now;
	26	+}
	27	+

examples/basic/lfo.ck+13−0

@@ -0,0 +1,13 @@
	1	+// using SinOsc.period (alternative to .freq)
	2	+
	3	+// sinosc
	4	+SinOsc lfo => dac;
	5	+// set period
	6	+1::second => lfo.period;
	7	+
	8	+// infinite time loop
	9	+while( true )
	10	+{
	11	+ <<< lfo.last(), "" >>>;
	12	+ 50::ms => now;
	13	+}

examples/basic/moe++.ck+42−0

@@ -0,0 +1,42 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe++ larry++ curly++
	3	+
	4	+// source to filter to dac
	5	+SndBuf i => BiQuad f => Gain g => dac;
	6	+// second formant
	7	+i => BiQuad f2 => g;
	8	+// third formant
	9	+i => BiQuad f3 => g;
	10	+
	11	+// set the filter's pole radius
	12	+.995 => f.prad; .995 => f2.prad; .995 => f3.prad;
	13	+// set equal gain zeros
	14	+1 => f.eqzs; 1 => f2.eqzs; 1 => f3.eqzs;
	15	+// initialize float variable
	16	+1.5 * 3.14 => float v;
	17	+// set filter gain
	18	+.2 => f.gain; .04 => f2.gain; .01 => f3.gain;
	19	+// load glottal pop
	20	+"special:glot_pop" => i.read;
	21	+// play
	22	+1.0 => i.rate;
	23	+
	24	+
	25	+// infinite time-loop
	26	+while( true )
	27	+{
	28	+ // set the current pos
	29	+ 0 => i.pos;
	30	+
	31	+ // sweep the filter resonant frequency
	32	+ 660.0 + Math.sin(v)*80.0 => f.pfreq;
	33	+ 1780.0 + Math.sin(v.5)50.0 => f2.pfreq;
	34	+ 2410.0 + Math.sin(v.25)150.0 => f3.pfreq;
	35	+
	36	+ // increment v
	37	+ v + .05 => v;
	38	+ // gain
	39	+ 0.2 + Math.sin(v)*.2 => g.gain;
	40	+ // advance time
	41	+ (80.0 + Math.sin(v2.0)10.0)::ms => now;
	42	+}

examples/basic/moe.ck+27−0

@@ -0,0 +1,27 @@
	1	+// run each stooge, or run three stooges concurrently
	2	+// %> chuck moe larry curly
	3	+
	4	+// impulse to filter to dac
	5	+Impulse i => BiQuad f => dac;
	6	+// set the filter's pole radius
	7	+.99 => f.prad;
	8	+// set equal gain zeros
	9	+1 => f.eqzs;
	10	+// initialize float variable
	11	+0.0 => float v;
	12	+// set filter gain
	13	+.5 => f.gain;
	14	+
	15	+// infinite time-loop
	16	+while( true )
	17	+{
	18	+ // set the current sample/impulse
	19	+ 1.0 => i.next;
	20	+ // sweep the filter resonant frequency
	21	+ Std.fabs(Math.sin(v)) * 4000.0 => f.pfreq;
	22	+ // increment v
	23	+ v + .1 => v;
	24	+ // advance time
	25	+ 100::ms => now;
	26	+}
	27	+

examples/basic/rec-auto-stereo.ck+29−0

@@ -0,0 +1,29 @@
	1	+// chuck this with other shreds to record to file
	2	+// example> chuck foo.ck bar.ck rec (see also rec2.ck)
	3	+
	4	+// pull samples from the dac
	5	+// WvOut2 -> stereo operation
	6	+dac => WvOut2 w => blackhole;
	7	+
	8	+// set the prefix, which will prepended to the filename
	9	+// do this if you want the file to appear automatically
	10	+// in another directory. if this isn't set, the file
	11	+// should appear in the directory you run chuck from
	12	+// with only the date and time.
	13	+"chuck-session" => w.autoPrefix;
	14	+
	15	+// this is the output file name
	16	+"special:auto" => w.wavFilename;
	17	+
	18	+// print it out
	19	+<<<"writing to file: ", w.filename()>>>;
	20	+
	21	+// any gain you want for the output
	22	+.5 => w.fileGain;
	23	+
	24	+// temporary workaround to automatically close file on remove-shred
	25	+null @=> w;
	26	+
	27	+// infinite time loop...
	28	+// ctrl-c will stop it, or modify to desired duration
	29	+while( true ) 1::second => now;

examples/basic/rec-auto.ck+28−0

@@ -0,0 +1,28 @@
	1	+// chuck this with other shreds to record to file
	2	+// example> chuck foo.ck bar.ck rec (see also rec2.ck)
	3	+
	4	+// pull samples from the dac
	5	+dac => Gain g => WvOut w => blackhole;
	6	+
	7	+// set the prefix, which will prepended to the filename
	8	+// do this if you want the file to appear automatically
	9	+// in another directory. if this isn't set, the file
	10	+// should appear in the directory you run chuck from
	11	+// with only the date and time.
	12	+"chuck-session" => w.autoPrefix;
	13	+
	14	+// this is the output file name
	15	+"special:auto" => w.wavFilename;
	16	+
	17	+// print it out
	18	+<<<"writing to file: ", w.filename()>>>;
	19	+
	20	+// any gain you want for the output
	21	+.5 => g.gain;
	22	+
	23	+// temporary workaround to automatically close file on remove-shred
	24	+null @=> w;
	25	+
	26	+// infinite time loop...
	27	+// ctrl-c will stop it, or modify to desired duration
	28	+while( true ) 1::second => now;

examples/basic/rec.ck+23−0

@@ -0,0 +1,23 @@
	1	+// chuck this with other shreds to record to file
	2	+// example> chuck foo.ck bar.ck rec (see also rec2.ck)
	3	+
	4	+// arguments: rec:<filename>
	5	+
	6	+// get name
	7	+me.arg(0) => string filename;
	8	+if( filename.length() == 0 ) "foo.wav" => filename;
	9	+
	10	+// pull samples from the dac
	11	+dac => Gain g => WvOut w => blackhole;
	12	+// this is the output file name
	13	+filename => w.wavFilename;
	14	+<<<"writing to file:", "'" + w.filename() + "'">>>;
	15	+// any gain you want for the output
	16	+.5 => g.gain;
	17	+
	18	+// temporary workaround to automatically close file on remove-shred
	19	+null @=> w;
	20	+
	21	+// infinite time loop...
	22	+// ctrl-c will stop it, or modify to desired duration
	23	+while( true ) 1::second => now;

examples/basic/ring.ck+26−0

@@ -0,0 +1,26 @@
	1	+//--------------------------------------------
	2	+// simple ring modulation
	3	+//
	4	+// any ugen has .op:
	5	+// ---
	6	+// -1 pass through the input
	7	+// 0 stop input
	8	+// 1 add inputs (default)
	9	+// 2 subtract from first input
	10	+// 3 multiply inputs
	11	+// 4 divide from first input
	12	+//--------------------------------------------
	13	+
	14	+// the patch
	15	+adc => Gain g => dac;
	16	+SinOsc s => g;
	17	+
	18	+// multiply inputs at g
	19	+3 => g.op;
	20	+
	21	+// presets
	22	+400.0 => s.freq;
	23	+
	24	+// time loop
	25	+while( true )
	26	+ 1::second => now;

examples/basic/sndbuf.ck+17−0

@@ -0,0 +1,17 @@
	1	+// sound file
	2	+me.dir() + "/../data/snare.wav" => string filename;
	3	+if( me.args() ) me.arg(0) => filename;
	4	+
	5	+// the patch
	6	+SndBuf buf => dac;
	7	+// load the file
	8	+filename => buf.read;
	9	+
	10	+// time loop
	11	+while( true )
	12	+{
	13	+ 0 => buf.pos;
	14	+ Math.random2f(.2,.5) => buf.gain;
	15	+ Math.random2f(.5,1.5) => buf.rate;
	16	+ 100::ms => now;
	17	+}

examples/basic/step.ck+13−0

@@ -0,0 +1,13 @@
	1	+// step gen to dac
	2	+Step s => dac;
	3	+.5 => float v;
	4	+
	5	+// infinite time-loop
	6	+while( 1 )
	7	+{
	8	+ // advance time
	9	+ 1::ms => now;
	10	+ // set value
	11	+ v => s.next;
	12	+ -v => v;
	13	+}

examples/basic/tick.ck+9−0

@@ -0,0 +1,9 @@
	1	+// tick tock
	2	+
	3	+// infinite time loop
	4	+while( true )
	5	+{
	6	+ // print now in seconds
	7	+ <<< "tick:", (now / second), "seconds" >>>;
	8	+ 1::second => now;
	9	+}

examples/basic/tick2.ck+12−0

@@ -0,0 +1,12 @@
	1	+// tick tock
	2	+
	3	+// wait until the start of the next second
	4	+second - (now % second) => now;
	5	+
	6	+// infinite time loop
	7	+while( true )
	8	+{
	9	+ // print now in seconds
	10	+ <<< "tick:", (now / second) $ int, "seconds" >>>;
	11	+ 1::second => now;
	12	+}

examples/basic/unchuck.ck+41−0

@@ -0,0 +1,41 @@
	1	+// noise generator, biquad filter, dac (audio output)
	2	+Noise n => BiQuad f => dac;
	3	+// set biquad pole radius
	4	+.99 => f.prad;
	5	+// set biquad gain
	6	+.025 => f.gain;
	7	+// set equal zeros
	8	+1 => f.eqzs;
	9	+// our float
	10	+0.0 => float t;
	11	+
	12	+3::second + now => time later;
	13	+// time-loop
	14	+while( now < later )
	15	+{
	16	+ // sweep the filter resonant frequency
	17	+ 100.0 + Std.fabs(Math.sin(t)) * 1000.0 => f.pfreq;
	18	+ t + .05 => t;
	19	+ // advance time
	20	+ 100::ms => now;
	21	+}
	22	+
	23	+// unlink the ugen f from dac
	24	+f =< dac;
	25	+
	26	+// let more time pass
	27	+3::second => now;
	28	+
	29	+// relink
	30	+f => dac;
	31	+
	32	+// time-loop
	33	+3::second + now => later;
	34	+while( now < later )
	35	+{
	36	+ // resume sweep
	37	+ 100.0 + Std.fabs(Math.sin(t)) * 1000.0 => f.pfreq;
	38	+ t + .05 => t;
	39	+ // advance time
	40	+ 100::ms => now;
	41	+}

examples/basic/valueat.ck+24−0

@@ -0,0 +1,24 @@
	1	+// (see sndbuf.ck or otf_01.ck for non-insane usage of sndbuf)
	2	+SndBuf buf;
	3	+me.dir() + "/../data/kick.wav" => buf.read;
	4	+
	5	+// the patch (no sndbuf involved)
	6	+Impulse i => dac;
	7	+
	8	+// infinite time-loop
	9	+while( true )
	10	+{
	11	+ // index
	12	+ int pos;
	13	+
	14	+ // repeat this many times
	15	+ repeat( buf.samples() )
	16	+ {
	17	+ // set next sample
	18	+ buf.valueAt( pos ) => i.next;
	19	+ // increment index
	20	+ pos++;
	21	+ // advance time by one samp
	22	+ 1::samp => now;
	23	+ }
	24	+}

examples/basic/whirl.ck+16−0

@@ -0,0 +1,16 @@
	1	+// sine to dac
	2	+SinOsc s => dac;
	3	+// let's turn down gain, for this can be loud and annoying
	4	+.15 => s.gain;
	5	+
	6	+// infinite time loop
	7	+0.0 => float t;
	8	+while( true )
	9	+{
	10	+ // modulate
	11	+ 30 + ( Math.sin(t) + 1.0 ) * 10000.0 => s.sfreq;
	12	+ t + .004 => t;
	13	+
	14	+ // advance time
	15	+ 1::ms => now;
	16	+}

examples/basic/whole.ck+30−0

@@ -0,0 +1,30 @@
	1	+// another candidate for lamest demo
	2	+
	3	+// patch
	4	+SinOsc s => JCRev r => dac;
	5	+.5 => r.gain;
	6	+.075 => r.mix;
	7	+
	8	+// note number
	9	+20 => float note;
	10	+
	11	+// go up to 127
	12	+while( note < 128 )
	13	+{
	14	+ // convert MIDI note to hz
	15	+ Std.mtof( note ) => s.freq;
	16	+ // turn down the volume gradually
	17	+ .5 - (note/256.0) => s.gain;
	18	+
	19	+ // move up by whole step
	20	+ note + 2 => note;
	21	+
	22	+ // advance time
	23	+ .125::second => now;
	24	+}
	25	+
	26	+// turn off s
	27	+0 => s.gain;
	28	+// wait a bit
	29	+2::second => now;
	30	+

examples/basic/wind.ck+20−0

@@ -0,0 +1,20 @@
	1	+// noise generator, biquad filter, dac (audio output)
	2	+Noise n => BiQuad f => dac;
	3	+// set biquad pole radius
	4	+.99 => f.prad;
	5	+// set biquad gain
	6	+.05 => f.gain;
	7	+// set equal zeros
	8	+1 => f.eqzs;
	9	+// our float
	10	+0.0 => float t;
	11	+
	12	+// infinite time-loop
	13	+while( true )
	14	+{
	15	+ // sweep the filter resonant frequency
	16	+ 100.0 + Std.fabs(Math.sin(t)) * 15000.0 => f.pfreq;
	17	+ t + .01 => t;
	18	+ // advance time
	19	+ 5::ms => now;
	20	+}

examples/basic/wind2.ck+37−0

@@ -0,0 +1,37 @@
	1	+// noise generator, biquad filter, dac (audio output)
	2	+Noise n => BiQuad f => dac;
	3	+// set biquad pole radius
	4	+.99 => f.prad;
	5	+// set biquad gain
	6	+.05 => f.gain;
	7	+// set equal zeros
	8	+1 => f.eqzs;
	9	+// our float
	10	+0.0 => float t;
	11	+
	12	+// concurrent control
	13	+fun void wind_gain( )
	14	+{
	15	+ 0.0 => float g;
	16	+
	17	+ // time loop to ramp up the gain / oscillate
	18	+ while( true )
	19	+ {
	20	+ Std.fabs( Math.sin( g ) ) => n.gain;
	21	+ g + .001 => g;
	22	+ 10::ms => now;
	23	+ }
	24	+}
	25	+
	26	+// run wind_gain on anothre shred
	27	+spork ~ wind_gain();
	28	+
	29	+// infinite time-loop
	30	+while( true )
	31	+{
	32	+ // sweep the filter resonant frequency
	33	+ 100.0 + Std.fabs(Math.sin(t)) * 15000.0 => f.pfreq;
	34	+ t + .01 => t;
	35	+ // advance time
	36	+ 100::ms => now;
	37	+}

examples/basic/zerox.ck+14−0

@@ -0,0 +1,14 @@
	1	+// step generator, zero crossing detector, dac
	2	+Step s => ZeroX z => dac;
	3	+1.0 => float v;
	4	+
	5	+// infnite time-loop
	6	+while( true )
	7	+{
	8	+ // set the step value
	9	+ v => s.next;
	10	+ // change step value
	11	+ -v => v;
	12	+ // advance time
	13	+ 100::ms => now;
	14	+}

moving examples to top dir

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code