I'm pretty sure there's a bug in the way ChucK prints time. Or there may be a bug in the way I think. Bear with me...

You would expect that two time values that print identically would compare as equal. But I can show you a case where t0 and t1 print as "44100.000000" yet they're not equal. You'd also expect t1 to have a fractional part of 0.0. But in this case:

   <<< (t1 % 1::second) >>> prints "1.000000"

and

   <<< t1 - (t1 % 1::second) >>> prints "44099.000000"

Mind you, I'm NOT complaining about roundoff error -- I understand that converting between floats and time is subject to roundoff -- but it has certainly cost me a LOT of debugging time discovering that 44100.000000 != 44100.000000. It's a printing bug.

Here's the code. It's longer than it needs to be, so if anyone asks for it, I'll strip it down to a three line example.

// In ChucK, two times can appear to be equal when printed,
// but compare as not equal, as demonstrated here.

72.511111111 => float tempo;    // intentionally subject to roundoff

now => time t0;            // base time
100.0 => float b0;        // beat at t0
1::second / tempo => dur i0;    // duration of one beat

// convert from system time to beat
fun float time_to_beat(time t) { return b0 + (t - t0)/i0; }

// convert from beat to system time
fun time beat_to_time(float b) { return t0 + (b - b0)::i0; }

// for debugging: extract fractional and whole parts from time
fun dur frac_time(time t) { return t % 1::samp; }
fun time whol_time(time t) { return t - (t % 1::samp); }

fun void test_time(time t0) {
    beat_to_time(time_to_beat(t0)) => time t1;
    if (t0 != t1) {
    <<< "t0:",t0,"is not equal to t1:",t1>>>;
    frac_time(t0) => dur f0;
    frac_time(t1) => dur f1;
    whol_time(t0) => time w0;
    whol_time(t1) => time w1;
    <<< f0, f1, f0==f1, w0, w1, w0==w1 >>>;
    }
}

test_time(now);
test_time(now+1::second);
test_time(now+1::samp);