- chuck-users - lists.cs.princeton.edu

miniAudicle Installation Error
by Les Hall 10 Dec '09

10 Dec '09

Hi folks, I just tried to install miniAudicle 0.2.0 (gidora) on my eMac and got the following error: The following disk images failed to mount miniAudicle-0.2.0a.dmg no mountable file systems I'm running OSX 10.3.9, which is kind of old. I cannot upgrade my OSX because the SuperDrive failed (for the second time), and besides I'm not to keen on paying Apple "rent" to use my eMac. I say "rent" because their OSX upgrades cost $129 and come out every 18 months or so, resulting in a "rental" payment to Apple of $7 per month. This is unacceptable to me so I cannot and will not upgrade my OSX. Is this decision also locking me out of miniAudicle upgrades? Thanks for your reply. Les

1 0

Problem with mixed float int lists
by Hans Aberg 10 Dec '09

10 Dec '09

ChucK does not admit explicit lists with numbers bot having and not having the decimal point, as in the example below. The problem is really that I made a program that writes tuning data to a file, which then should be pasted back into a .ck file. If the float value has not fractional part, 'chuck' writes it without decimal point. For example, it writes 440 Hz not 440.0 Hz. The first idea would be have 'chuck' always writing floats with a decimal point. But if the tuning data comes from some other source, it may not have a decimal point. One then ends up editing this data by hand, which is cumbersome. So I think 'chuck' should be able to convert explicit mixed float-int lists to float[]. There might also be some floats formatting capabilities. Hans ---- float_int_list.ck ---- [0.0, 1.0] @=> float as[]; // OK. [0, 1.0] @=> float bs[]; // array init [...] contains incompatible types... fun void f(float xs[]) {} f([0.0, 1.2]); // OK. f([0, 1.0]); // array init [...] contains incompatible types... f([0, 1]); // argument type(s) do not match: --------

2 7

initialization of static variables
by Robert Poor 09 Dec '09

09 Dec '09

Gang: I now understand a bit more about initialization of static variables -- more accurately, about execution of top-level code -- and while it's not earth-shattering, I thought I'd pass it along. It may avoid some astonishment. The rules are simple, but are different than I thought: -- top level forms INSIDE a class definition are executed every time an instance of that class is created. -- top level forms OUTSIDE of a class definition are executed once when the file loads. To see the implication on initializing a static variable, consider the following: ===== file: t1.ck public class Statix { // UNO is set with to new value at every call to 'new Statix' static Object @ UNO; (new Object) @=> UNO; // DUE is set once after the first call to 'new Statix' static Object @ DUE; if (DUE == null) (new Object) @=> DUE; // TRE is set once when the file is loaded (see below) static Object @ TRE; <<< "at a: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; } <<< "at b: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; (new Statix) @=> Statix.TRE; <<< "at c: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; ===== file: t2.ck <<< "at d: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; new Statix @=> Statix @ _t1; <<< "at e: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; new Statix @=> Statix @ _t2; <<< "at f: UNO=", Statix.UNO, "DUE=", Statix.DUE, "TRE=", Statix.TRE >>>; ===== the output: % chuck t1.ck t2.ck at b: UNO= 0x0 DUE= 0x0 TRE= 0x0 at a: UNO= 0x5e5aa0 DUE= 0x5e5af0 TRE= 0x0 at c: UNO= 0x5e5aa0 DUE= 0x5e5af0 TRE= 0x5e6670 at d: UNO= 0x5e5aa0 DUE= 0x5e5af0 TRE= 0x5e6670 at a: UNO= 0x5e6ba0 DUE= 0x5e5af0 TRE= 0x5e6670 at e: UNO= 0x5e6ba0 DUE= 0x5e5af0 TRE= 0x5e6670 at a: UNO= 0x5e6c00 DUE= 0x5e5af0 TRE= 0x5e6670 at f: UNO= 0x5e6c00 DUE= 0x5e5af0 TRE= 0x5e6670

2 3

background music
by Tom Lieber 07 Dec '09

07 Dec '09

could you guys make this a little better for me? one file max tho. thx 100::ms => dur d; Step s => dac; 0.1 => s.gain; Moog w => dac; 0.1 => w.gain; 1 => w.noteOn; Moog w2 => Envelope env => dac; .2 => w2.gain; 1 => w2.noteOn; d => env.duration; 1 => env.keyOn; fun float warble() { return Std.rand2f(2.5/1.01, 2.5*1.01); } fun void sweep(float freq, dur d) { w.freq() => float start; for(0 => int i; i < 10; i++) { (i / 10.) * (freq - start) + start => w.freq; w.freq() * warble() => w2.freq; d / 10. => now; } freq => w.freq; freq * warble() => w2.freq; walk(env.target(), .0, 1, .3) => env.target; 1 => env.keyOn; } fun void yay() { d * 4 => dur e; while(true) { Std.rand2(1, 2)::e => now; spork ~ sweep(Std.rand2(60, 70) => Std.mtof, Std.rand2f(1/60., 1/10.)::e); } } spork ~ yay(); while(true) { Std.rand2(1, 2)::d => now; 0.1 => s.next; Std.rand2(1, 2)::d => now; -0.1 => s.next; d => now; 1 => s.next; d => now; -1 => s.next; } fun float walk(float current, float min, float max, float step) { Std.rand2f(current - step, current + step) => float n; if(n < min) min => n; if(n > max) max => n; return n; } -- Tom Lieber http://AllTom.com/

1 0

Bouncing .ck to audio files
by Ryan Wieghard 07 Dec '09

07 Dec '09

Hey all, I was wondering if there is a way to make the output of my .ck file an mp3 or wav file. Thanks Ryan. -- "Le savant n’étudie pas la nature parce que cela est utile ; il l’étudie parce qu’il y prend plaisir et il y prend plaisir parce qu’elle est belle." - Henri Poincaré

6 6

FormSwep
by Robert Poor 07 Dec '09

07 Dec '09

Is FormSwep available in ChucK? I see it in the source code, I see it described in previous STK docs, the Moog UGen makes mention of it, but attempting to compile: FormSwep fs => blackhole; errors with "undefined type FormSwep in declaration" - Rob

1 0

chuck 1.2.1.3 weird debug messages and aggregate devices
by mike clemow 06 Dec '09

06 Dec '09

Hi, chuck version: 1.2.1.3 (dracula) exe target: mac os x : intel I'm having trouble getting Chuck to not segfault using aggregate devices (only when trying to use more channels than in the first device) in Mac OS X 10.6. Has this always been an issue? Working around this for now, however, I'm curious what others' experiences have been with aggregate devices. Also, what's with the malloc messages in my newly compiled-from-source 1.2.1.3? Again, curious... Best, Mike -- http://michaelclemow.com http://semiotech.org

2 2

Local-static bug
by Hans Aberg 05 Dec '09

05 Dec '09

For some reason, 'chuck' does not admit different type argument overloading on local & static class functions. The example below works as long as one does not call the static function. So either it should complain that it is illegal when encountering it in the class or admit this kind of overloading. Originally, I used a function "add" on intervals - not as artificial as the example below. Hans ---- local-static.ck ---- class Test { fun void print(float x) { chout <= "Local fun: " <= x <= "\n"; } fun static void print(float x, float y) { chout <= "Static fun: (" <= x <= ", " <= y <= ")\n"; } } Test.print(1, 2); // This call causes the run error. //Test t; //t.print(2); ---- run ---- $ chuck local-static.ck [local-static.ck]:line(11): cannot access member 'Test.print' without object instance... ----

1 0

the novice chucKster trying to navigate the Event class
by Ryan Wieghard 01 Dec '09

01 Dec '09

Hello! So I am trying to design a data structure that is a list of musical events that are composed of duration, amplitude, and a list of four pitches to be assigned to SinOsc's . When I was constructing the idea, I called the atomic units of the lists "events" not knowing that there existed an Event class in chucK. When I researched the Event class, however, I become confused as to whether or not extended that class would be appropriate for what I am trying to achieve. I was wondering if someone could advise me the easiest way of going about creating a list of lists of two ints and a list: ["Event"Object1, "Event"Object2, ...,"Event"ObjectN] where "Event"Object[i] = [int amplitude, int duration, [pitch1,pitch2,pitch3,pitch4]] The idea is that one can simply iterate across the above list of "Event"Objects and assign a bank of four SinOsc's the pitchs 1 through 4; assign an envelope's gain to the amplitude, and advanced time by duration. I apologize if the above is an ugly articulation of my idea. Sincerely, Ryan. -- "Le savant n’étudie pas la nature parce que cela est utile ; il l’étudie parce qu’il y prend plaisir et il y prend plaisir parce qu’elle est belle." - Henri Poincaré

2 1

Semaphore class: wait for timeout or signal, whichever comes first
by Robert Poor 29 Nov '09

29 Nov '09

All: Based on some ideas originally by Tom Lieber, here is a Semaphore class that makes it easy to wait for a specific time OR for an external signal, whichever comes first. I've been using it extensively in my real-time performance code and would like to believe it's well debugged. Presented here in case anyone else might find it useful. Comments, questions welcome. Best, - Rob Poor // semaphore.ck -- wait until a specific time arrives or an external // signal is generated, whichever comes first. // // Sample Usage =================================================== // class TickleSignal extends Object {} // TickleSignal tickle_signal; // Semaphore semaphore; // // repeat(10) { // now + 2::second => time test_end_time; // spork ~ tickler_proc(); // semaphore.wait_for(1::second) @=> Object @ cause; // <<< "semaphore woke due to", cause.toString() >>>; // test_end_time => now; // } // // fun void tickler_proc() { // Std.rand2f(0.0, 2.0)::second => now; // semaphore.signal(tickle_signal); // } // ================================================================ // Author: Robert Poor <rdpoor(a)gmail.com>, November 2009 // TimeoutArrived is used as the <cause> argument for signal() when // the semaphore wakes due to timeout. While it's not neccessary to // define a custom class -- any object can be used as the <cause> // argument to signal() -- a custom class has the nice property that // .toString() will print out the class name. See Sample Usage above // to see how a custom class may be used as the argument to signal(). class TimeoutArrived extends Object {}; // ================================================================ // ================================================================ // The Semaphore class supports waiting for an external signal or a // timeout. public class Semaphore extends Event { // ================================================================ // class constants // TIMEOUT_ARRIVED is a constant returned by wait() to indicate // that the wait() was terminated by timeout rather than by a user // signal. static TimeoutArrived @ TIMEOUT_ARRIVED; new TimeoutArrived @=> TIMEOUT_ARRIVED; // ================================================================ // class methods // ChucK 1.2.1.3 exhibits scheduling bugs when passed time values // with non-zero fractional parts. truncate_time() removes the // fractional part to work around the bug. (See set_timeout(t) // for usage.) fun static time truncate_time(time t) { return t - (t % samp); } // ================================================================ // instance variables Object @ _cause; time _timeout_time; // ================================================================ // public instance methods // ================ // wait() blocks until someone calls signal(cause). It then // returns the cause argument. fun Object wait() { this => now; // wait here for call to signal() return _cause; } // ================ // signal(cause) signals the semaphore, allowing it to return from // a call to wait() with the given cause. fun Semaphore signal(Object cause) { cause @=> _cause; // remember the cause of the signal clear_timeouts(); // inhibit pending timeouts this.broadcast(); // unblock the wait() me.yield(); // allow wait()'ing thread to run return this; } // ================ // set_timeout(time) generates a call to signal(TIMEOUT_ARRIVED) in // the future. If <time> has already passed, no timeout is set // and set_timeout() returns null. fun Semaphore set_timeout(dur duration) { return set_timeout(now + duration); } fun Semaphore set_timeout(time t) { if ((truncate_time(t) => _timeout_time) <= now) return null; spork ~ _timeout_proc(t); me.yield(); return this; } // ================ // clear_timeouts() prevents any pending timeouts from generating // a signal(). // // Implementation note: each call to set_timeout() spawns a new // _timeout_proc(), and once spawned, a proc cannot be killed or // interupted. To inhibit subsequent calls to signal(), we set // _timeout_time to an "impossible" value (i.e. a time in the // past) to inhibit the generation of the signals -- see the // implementation of _timeout_proc() to see why this works. fun Semaphore clear_timeouts() { now - 1::second => _timeout_time; return this; } // ================ // wait_for() and wait_until() combine a call to set_timeout() // followed by a wait(): they will block until the desired time // arrives OR until <this>.signal() is called from another thread, // whichever comes first. fun Object wait_for(dur duration) { return wait_until(now + duration); } fun Object wait_until(time t) { if (set_timeout(t) == null) { return TIMEOUT_ARRIVED; // don't wait() if time already passed } else { return this.wait(); } } // ================================================================ // private methods // _timeout_proc() is spawned in its own thread at each call to // set_timeout(). It blocks until the requested time, and if // the timeout is still current (i.e. now == _timeout_time), it // calls <this>.signal(TIMEOUT_ARRIVED) to unblock the wait(). fun void _timeout_proc(time t) { t => now; // wait until the time arrives // Signal the Semaphore only if this timeout is current if (now == _timeout_time) this.signal(TIMEOUT_ARRIVED); } }

1 0