/* * Graphics Gems III: Fast Generation of Cyclic Sequences * * programmed by Alan Paeth (awpaeth@alumni.caltech.edu) * * These functions are implemented as macros which fall into two classes: * * sequences -- generate a cyclic set of N arbitrary values * triggers -- generate a cyclic set of N boolean test conditions. * * Macros come as a set. The first initializes (declarative), the second steps. * These are paired for VARIABLE / BOOLEAN triggering use. * The first are called "sequN" such as "getch()" and * will not introduce side-effects. A third macro named "testM" provides * boolean triggering expressions without altering the current step. Its value * is "true" after step "i" if the ith character in string M is non-zero. * * Note: these macros have been tuned for performance and internal consistency. * Unlike the book exposition, a cycle's current value is undefined until * *after* the first call to "cyclN" or "stepN". This style facilitates fast * testing as in "do { } while(condition)" loops at the expense of additional * first-use overhead, total amortized loop time remaining unchanged. The code * takes advantage of both register variables and the C "comma" operator. * Loops may be cycled symbolically, thereby reordering the initialization or * step macros to take advantage of specific compiler or problem optimizations. */ /* * Sequences * * The macro "sequN(parm1,...,parmN) initializes a sequence N values; * the macro "cyclN()" advances to (and returns in "t1") the next cyclic value. */ /* cycle: [a, b] (eqn 2.2) */ #define sequ2(a,b) register int t1, t2; t1 = (int)(b); t2 = t1^(int)(a) #define cycl2() (t1 ^= t2) /* cycle: [a, b, c] (eqn 3.3) */ #define sequ3(a,b,c) register int t1, t2, t3; \ t1 = (int)(c); t2 = t1^(int)(b); t3 = t2^(int)(a) #define cycl3() (t2 ^= (t1 ^ t3), t1 ^= t2) /* cycle: [a, b, c, d, e, f] (eqn 6.2) * * register t1 may be removed if value is not kept; t4 provides only an offset * a second table may be easily added to the LHS of the innermost subexpression * values may be cast as ints or the macro rewritten to support floats, etc. */ #define sequ6(a,b,c,d,e,f) register int t1,t2,t3,t4[7],*t5;t2=t3=1;t5= &t4[3];\ t4[1]=(a); t4[0]=(b); t4[2]=(c); t4[5]=(d); t4[6]=(e); t4[4]=(f) #define cycl6() (t1=t5[(t2 += t3, t3 += (~t2))]) /* cycle: [1, 2, 3] (eqn 3.3b, end) */ #define sequ123() register int t1, t2; t1 = 3; t2 = 1 #define cycl123() (t2 ^= t1, t1 ^= t2) /* * Triggers * * The macro "trigN() initializes a boolean cycle of N states. * the macro "stepN()" advances the state * the macro "testM" is a true expression at step i if M's ith char is '1'. */ /* trigger mod 2 (eqn 2.1) */ #define trig2() register int t1 = 0 #define step2() (t1 = !t1) #define test01() (!t1) #define test10() (t1) /* trigger mod 3 (eqn 3.2) */ #define trig3() register int t1, t2; t1 = t2 = 1 #define step3() (t1 ^= t2, t2 ^= t1) #define test100() (!t1) #define test010() (!t2) #define test001() (t1 == t2) #define test110() (t1 != t2) /* trigger mod 6 (eqn 6.3) */ #define trig6() register int t1, t2; t1 = -1; t2 = 1 #define step6() (t1 += t2, t2 += ~t1) #define test100000() ((t1 == 0) && (t2 == 0)) #define test100100() (!t2) #define test101000() (t1 == t2) #define test110000() (!t1) #define test110100() ((t1 == 0) || (t2 == 0)) #define test010111() (t1 != t2) #define test011111() ((t1 != 0) || (t2 != 0))