[Gridflow-cvs] [svn] commit: r3881 - in /trunk/doc: architecture.html optable.pd optable.tcl

gridflow-cvs at artengine.ca gridflow-cvs at artengine.ca
Mon Jun 16 13:54:07 EDT 2008


Author: matju
Date: Mon Jun 16 13:54:07 2008
New Revision: 3881

Log:
moved vecops from html to pd

Modified:
    trunk/doc/architecture.html
    trunk/doc/optable.pd
    trunk/doc/optable.tcl

Modified: trunk/doc/architecture.html
==============================================================================
--- trunk/doc/architecture.html (original)
+++ trunk/doc/architecture.html Mon Jun 16 13:54:07 2008
@@ -155,18 +155,6 @@
 <tr><td align="left" valign="top"><table bgcolor="white" border="0" cellpadding="4" cellspacing="1">
 <tr class="c3"><td><b>name</b></td><td><b>description</b></td><td><b>meaning in geometric context (indexmaps, polygons, in which each complex number is a point)</b></td><td><b>meaning in spectrum context (FFT) in which each number is a (cosine,sine) pair</b></td></tr>
 
-<tr class="c1"><td>C.*    </td><td>A*B</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C.*conj</td><td>A*conj(B)</td><td>--</td><td>--</td></tr>
-<tr class="c1"><td>C./    </td><td>A/B</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C./conj</td><td>A/conj(B)</td><td>--</td><td>--</td></tr>
-<tr class="c1"><td>C.sq-  </td><td>(A-B)*(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C.abs- </td><td>abs(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c1"><td>C.sin  </td><td>sin(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C.cos  </td><td>cos(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c1"><td>C.tanh </td><td>tanh(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C.exp  </td><td>exp(A-B)</td><td>--</td><td>--</td></tr>
-<tr class="c2"><td>C.log  </td><td>log(A-B)</td><td>--</td><td>--</td></tr>
-
 </table></td></tr></table></td></tr>
 
 <tr><td bgcolor="black">

Modified: trunk/doc/optable.pd
==============================================================================
--- trunk/doc/optable.pd (original)
+++ trunk/doc/optable.pd Mon Jun 16 13:54:07 2008
@@ -4,337 +4,341 @@
 #X text 96 0 description;
 #X text 512 0 effect on pixels;
 #X text 768 0 effect on coords;
-#X obj 0 32 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 32 op ignore;
-#X text 96 32  A ;
-#X text 512 32 no effect;
-#X text 768 32 no effect;
-#X obj 0 64 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 64 op put;
-#X text 96 64  B ;
-#X text 512 64 replace by;
-#X text 768 64 replace by;
-#X obj 0 96 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 96 op +;
-#X text 96 96  A + B ;
-#X text 512 96 brightness \,  crossfade;
-#X text 768 96 move \,  morph;
-#X obj 0 128 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 128 op -;
-#X text 96 128  A - B ;
-#X text 512 128 brightness \,  motion detection;
-#X text 768 128 move \,  motion detection;
-#X obj 0 160 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 160 op inv+;
-#X text 96 160  B - A ;
-#X text 512 160 negate then contrast;
-#X text 768 160 180 degree rotate then move;
-#X obj 0 192 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 192 op *;
-#X text 96 192  A * B ;
-#X text 512 192 contrast;
-#X text 768 192 zoom out;
-#X obj 0 224 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 224 op /;
-#X text 96 224  A / B \,  rounded towards zero ;
-#X text 512 224 contrast;
-#X text 768 224 zoom in;
-#X obj 0 256 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 256 op div;
-#X text 96 256  A / B \,  rounded downwards ;
-#X text 512 256 contrast;
-#X text 768 256 zoom in;
-#X obj 0 288 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 288 op inv*;
-#X text 96 288  B / A \,  rounded towards zero ;
-#X text 512 288 --;
-#X text 768 288 --;
-#X obj 0 320 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 320 op swapdiv;
-#X text 96 320  B / A \,  rounded downwards ;
-#X text 512 320 --;
-#X text 768 320 --;
-#X obj 0 352 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 352 op %;
-#X text 96 352  A % B \,  modulo (goes with div) ;
-#X text 512 352 --;
-#X text 768 352 tile;
-#X obj 0 384 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 384 op swap%;
-#X text 96 384  B % A \,  modulo (goes with div) ;
-#X text 512 384 --;
-#X text 768 384 --;
-#X obj 0 416 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 416 op rem;
-#X text 96 416  A % B \,  remainder (goes with /) ;
-#X text 512 416 --;
-#X text 768 416 --;
-#X obj 0 448 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 448 op swaprem;
-#X text 96 448  B % A \,  remainder (goes with /) ;
-#X text 512 448 --;
-#X text 768 448 --;
-#X obj 0 480 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 480 op gcd;
-#X text 96 480 greatest common divisor;
-#X text 512 480 --;
-#X text 768 480 --;
-#X obj 0 512 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 512 op lcm;
-#X text 96 512 least common multiple;
-#X text 512 512 --;
-#X text 768 512 --;
-#X obj 0 544 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 544 op |;
-#X text 96 544  A or B \,  bitwise ;
-#X text 512 544 bright munchies;
-#X text 768 544 bottomright munchies;
-#X obj 0 576 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 576 op ^;
-#X text 96 576  A xor B \,  bitwise ;
-#X text 512 576 symmetric munchies (fractal checkers);
-#X text 768 576 symmetric munchies (fractal checkers);
-#X obj 0 608 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 608 op &;
-#X text 96 608  A and B \,  bitwise ;
-#X text 512 608 dark munchies;
-#X text 768 608 topleft munchies;
-#X obj 0 640 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 640 op <<;
-#X text 96 640  A * (2**(B % 32)) \,  which is left-shifting ;
-#X text 512 640 like *;
-#X text 768 640 like *;
-#X obj 0 672 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 672 op >>;
-#X text 96 672  A / (2**(B % 32)) \,  which is right-shifting ;
-#X text 512 672 like / \, div;
-#X text 768 672 like / \, div;
-#X obj 0 704 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 704 op ||;
-#X text 96 704  if A is zero then B else A ;
-#X text 512 704 --;
-#X text 768 704 --;
-#X obj 0 736 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 736 op &&;
-#X text 96 736  if A is zero then zero else B;
-#X text 512 736 --;
-#X text 768 736 --;
-#X obj 0 768 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 768 op min;
-#X text 96 768  the lowest value in A \, B ;
-#X text 512 768 clipping;
-#X text 768 768 clipping (of individual points);
-#X obj 0 800 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 800 op max;
-#X text 96 800  the highest value in A \, B ;
-#X text 512 800 clipping;
-#X text 768 800 clipping (of individual points);
-#X obj 0 832 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 832 op cmp;
-#X text 96 832  -1 when A&lt \; B; 0 when A=B; 1 when A&gt;B. ;
-#X text 512 832 --;
-#X text 768 832 --;
-#X obj 0 864 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 864 op ==;
-#X text 96 864  is A equal to B ? 1=true \,  0=false ;
-#X text 512 864 --;
-#X text 768 864 --;
-#X obj 0 896 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 896 op !=;
-#X text 96 896  is A not equal to B ? ;
-#X text 512 896 --;
-#X text 768 896 --;
-#X obj 0 928 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 928 op >;
-#X text 96 928  is A greater than B ? ;
-#X text 512 928 --;
-#X text 768 928 --;
-#X obj 0 960 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 960 op <=;
-#X text 96 960  is A not greater than B ? ;
-#X text 512 960 --;
-#X text 768 960 --;
-#X obj 0 992 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 992 op <;
-#X text 96 992  is A less than B ? ;
-#X text 512 992 --;
-#X text 768 992 --;
-#X obj 0 1024 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1024 op >=;
-#X text 96 1024 is A not less than B ? ;
-#X text 512 1024 --;
-#X text 768 1024 --;
-#X obj 0 1056 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1056 op sin*;
-#X text 96 1056  B * sin(A) in centidegrees ;
-#X text 512 1056 --;
-#X text 768 1056 waves \,  rotations;
-#X obj 0 1088 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1088 op cos*;
-#X text 96 1088  B * cos(A) in centidegrees ;
-#X text 512 1088 --;
-#X text 768 1088 waves \,  rotations;
-#X obj 0 1120 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1120 op atan;
-#X text 96 1120  arctan(A/B) in centidegrees ;
-#X text 512 1120 --;
-#X text 768 1120 find angle to origin (part of polar transform);
-#X obj 0 1152 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1152 op tanh*;
-#X text 96 1152  B * tanh(A) in centidegrees ;
-#X text 512 1152 smooth clipping;
-#X text 768 1152 smooth clipping (of individual points) \,  neural sigmoid, fuzzy logic;
-#X obj 0 1184 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1184 op log*;
-#X text 96 1184  B * log(A) (in base e) ;
-#X text 512 1184 --;
-#X text 768 1184 --;
-#X obj 0 1216 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1216 op gamma;
-#X text 96 1216  floor(pow(a/256.0 \, 256.0/b)*256.0) ;
-#X text 512 1216 gamma correction;
-#X text 768 1216 --;
-#X obj 0 1248 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1248 op **;
-#X text 96 1248  A**B \,  that is, A raised to power B ;
-#X text 512 1248 gamma correction;
-#X text 768 1248 --;
-#X obj 0 1280 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1280 op abs-;
-#X text 96 1280  absolute value of (A-B) ;
-#X text 512 1280 --;
-#X text 768 1280 --;
-#X obj 0 1312 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1312 op rand;
-#X text 96 1312  randomly produces a non-negative number below A ;
-#X text 512 1312 --;
-#X text 768 1312 --;
-#X obj 0 1344 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1344 op sqrt;
-#X text 96 1344  square root of A \,  rounded downwards ;
-#X text 512 1344 --;
-#X text 768 1344 --;
-#X obj 0 1376 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1376 op sq-;
-#X text 96 1376  (A-B) times (A-B) ;
-#X text 512 1376 --;
-#X text 768 1376 --;
-#X obj 0 1408 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1408 op avg;
-#X text 96 1408  (A+B)/2 ;
-#X text 512 1408 --;
-#X text 768 1408 --;
-#X obj 0 1440 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1440 op hypot;
-#X text 96 1440  square root of (A*A+B*B) ;
-#X text 512 1440 --;
-#X text 768 1440 --;
-#X obj 0 1472 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1472 op clip+;
-#X text 96 1472  like A+B but overflow causes clipping instead of wrapping around (coming soon) ;
-#X text 512 1472 --;
-#X text 768 1472 --;
-#X obj 0 1504 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1504 op clip-;
-#X text 96 1504  like A-B but overflow causes clipping instead of wrapping around (coming soon) ;
-#X text 512 1504 --;
-#X text 768 1504 --;
-#X obj 0 1536 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1536 op erf*;
-#X text 96 1536  integral of e^(-x*x) dx ... (coming soon \;  what ought to be the scaling factor?) ;
-#X text 512 1536 --;
-#X text 768 1536 --;
-#X obj 0 1568 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1568 op weight;
-#X text 96 1568  number of "1" bits in an integer;
-#X text 512 1568 --;
-#X text 768 1568 --;
-#X obj 0 1600 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1600 op sin;
-#X text 96 1600 sin(A-B) in radians \,  float only;
-#X text 512 1600 --;
-#X text 768 1600 --;
-#X obj 0 1632 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1632 op cos;
-#X text 96 1632 cos(A-B) in radians \,  float only;
-#X text 512 1632 --;
-#X text 768 1632 --;
-#X obj 0 1664 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1664 op atan2;
-#X text 96 1664 atan2(A \, B) in radians, float only;
-#X text 512 1664 --;
-#X text 768 1664 --;
-#X obj 0 1696 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1696 op tanh;
-#X text 96 1696 tanh(A-B) in radians \,  float only;
-#X text 512 1696 --;
-#X text 768 1696 --;
-#X obj 0 1728 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 1728 op exp;
-#X text 96 1728 exp(A-B) in radians \,  float only;
-#X text 512 1728 --;
-#X text 768 1728 --;
-#X obj 0 1760 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 1760 op log;
-#X text 96 1760 log(A-B) in radians \,  float only;
-#X text 512 1760 --;
-#X text 768 1760 --;
-#X obj 10 1792 outlet;
-#X connect 6 0 280 0;
-#X connect 11 0 280 0;
-#X connect 16 0 280 0;
-#X connect 21 0 280 0;
-#X connect 26 0 280 0;
-#X connect 31 0 280 0;
-#X connect 36 0 280 0;
-#X connect 41 0 280 0;
-#X connect 46 0 280 0;
-#X connect 51 0 280 0;
-#X connect 56 0 280 0;
-#X connect 61 0 280 0;
-#X connect 66 0 280 0;
-#X connect 71 0 280 0;
-#X connect 76 0 280 0;
-#X connect 81 0 280 0;
-#X connect 86 0 280 0;
-#X connect 91 0 280 0;
-#X connect 96 0 280 0;
-#X connect 101 0 280 0;
-#X connect 106 0 280 0;
-#X connect 111 0 280 0;
-#X connect 116 0 280 0;
-#X connect 121 0 280 0;
-#X connect 126 0 280 0;
-#X connect 131 0 280 0;
-#X connect 136 0 280 0;
-#X connect 141 0 280 0;
-#X connect 146 0 280 0;
-#X connect 151 0 280 0;
-#X connect 156 0 280 0;
-#X connect 161 0 280 0;
-#X connect 166 0 280 0;
-#X connect 171 0 280 0;
-#X connect 176 0 280 0;
-#X connect 181 0 280 0;
-#X connect 186 0 280 0;
-#X connect 191 0 280 0;
-#X connect 196 0 280 0;
-#X connect 201 0 280 0;
-#X connect 206 0 280 0;
-#X connect 211 0 280 0;
-#X connect 216 0 280 0;
-#X connect 221 0 280 0;
-#X connect 226 0 280 0;
-#X connect 231 0 280 0;
-#X connect 236 0 280 0;
-#X connect 241 0 280 0;
-#X connect 246 0 280 0;
-#X connect 251 0 280 0;
-#X connect 256 0 280 0;
-#X connect 261 0 280 0;
-#X connect 266 0 280 0;
-#X connect 271 0 280 0;
-#X connect 276 0 280 0;
-#X obj 95 0 cnv 0 0 1792 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 511 0 cnv 0 0 1792 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 767 0 cnv 0 0 1792 empty empty empty -1 12 0 14 0 -66577 0;
+#X obj 0 48 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 48 op ignore;
+#X text 96 48  A ;
+#X text 512 48 no effect;
+#X text 768 48 no effect;
+#X obj 0 80 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 80 op put;
+#X text 96 80  B ;
+#X text 512 80 replace by;
+#X text 768 80 replace by;
+#X obj 0 112 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 112 op +;
+#X text 96 112  A + B ;
+#X text 512 112 brightness \,  crossfade;
+#X text 768 112 move \,  morph;
+#X obj 0 144 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 144 op -;
+#X text 96 144  A - B ;
+#X text 512 144 brightness \,  motion detection;
+#X text 768 144 move \,  motion detection;
+#X obj 0 176 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 176 op inv+;
+#X text 96 176  B - A ;
+#X text 512 176 negate then contrast;
+#X text 768 176 180 degree rotate then move;
+#X obj 0 208 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 208 op *;
+#X text 96 208  A * B ;
+#X text 512 208 contrast;
+#X text 768 208 zoom out;
+#X obj 0 240 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 240 op /;
+#X text 96 240  A / B \,  rounded towards zero ;
+#X text 512 240 contrast;
+#X text 768 240 zoom in;
+#X obj 0 272 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 272 op div;
+#X text 96 272  A / B \,  rounded downwards ;
+#X text 512 272 contrast;
+#X text 768 272 zoom in;
+#X obj 0 304 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 304 op inv*;
+#X text 96 304  B / A \,  rounded towards zero ;
+#X text 512 304 --;
+#X text 768 304 --;
+#X obj 0 336 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 336 op swapdiv;
+#X text 96 336  B / A \,  rounded downwards ;
+#X text 512 336 --;
+#X text 768 336 --;
+#X obj 0 368 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 368 op %;
+#X text 96 368  A % B \,  modulo (goes with div) ;
+#X text 512 368 --;
+#X text 768 368 tile;
+#X obj 0 400 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 400 op swap%;
+#X text 96 400  B % A \,  modulo (goes with div) ;
+#X text 512 400 --;
+#X text 768 400 --;
+#X obj 0 432 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 432 op rem;
+#X text 96 432  A % B \,  remainder (goes with /) ;
+#X text 512 432 --;
+#X text 768 432 --;
+#X obj 0 464 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 464 op swaprem;
+#X text 96 464  B % A \,  remainder (goes with /) ;
+#X text 512 464 --;
+#X text 768 464 --;
+#X obj 0 496 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 496 op gcd;
+#X text 96 496 greatest common divisor;
+#X text 512 496 --;
+#X text 768 496 --;
+#X obj 0 528 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 528 op lcm;
+#X text 96 528 least common multiple;
+#X text 512 528 --;
+#X text 768 528 --;
+#X obj 0 560 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 560 op |;
+#X text 96 560  A or B \,  bitwise ;
+#X text 512 560 bright munchies;
+#X text 768 560 bottomright munchies;
+#X obj 0 592 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 592 op ^;
+#X text 96 592  A xor B \,  bitwise ;
+#X text 512 592 symmetric munchies (fractal checkers);
+#X text 768 592 symmetric munchies (fractal checkers);
+#X obj 0 624 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 624 op &;
+#X text 96 624  A and B \,  bitwise ;
+#X text 512 624 dark munchies;
+#X text 768 624 topleft munchies;
+#X obj 0 656 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 656 op <<;
+#X text 96 656  A * (2**(B % 32)) \,  which is left-shifting ;
+#X text 512 656 like *;
+#X text 768 656 like *;
+#X obj 0 688 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 688 op >>;
+#X text 96 688  A / (2**(B % 32)) \,  which is right-shifting ;
+#X text 512 688 like / \, div;
+#X text 768 688 like / \, div;
+#X obj 0 720 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 720 op ||;
+#X text 96 720  if A is zero then B else A ;
+#X text 512 720 --;
+#X text 768 720 --;
+#X obj 0 752 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 752 op &&;
+#X text 96 752  if A is zero then zero else B;
+#X text 512 752 --;
+#X text 768 752 --;
+#X obj 0 784 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 784 op min;
+#X text 96 784  the lowest value in A \, B ;
+#X text 512 784 clipping;
+#X text 768 784 clipping (of individual points);
+#X obj 0 816 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 816 op max;
+#X text 96 816  the highest value in A \, B ;
+#X text 512 816 clipping;
+#X text 768 816 clipping (of individual points);
+#X obj 0 848 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 848 op cmp;
+#X text 96 848  -1 when A&lt \; B; 0 when A=B; 1 when A&gt;B. ;
+#X text 512 848 --;
+#X text 768 848 --;
+#X obj 0 880 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 880 op ==;
+#X text 96 880  is A equal to B ? 1=true \,  0=false ;
+#X text 512 880 --;
+#X text 768 880 --;
+#X obj 0 912 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 912 op !=;
+#X text 96 912  is A not equal to B ? ;
+#X text 512 912 --;
+#X text 768 912 --;
+#X obj 0 944 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 944 op >;
+#X text 96 944  is A greater than B ? ;
+#X text 512 944 --;
+#X text 768 944 --;
+#X obj 0 976 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 976 op <=;
+#X text 96 976  is A not greater than B ? ;
+#X text 512 976 --;
+#X text 768 976 --;
+#X obj 0 1008 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1008 op <;
+#X text 96 1008  is A less than B ? ;
+#X text 512 1008 --;
+#X text 768 1008 --;
+#X obj 0 1040 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1040 op >=;
+#X text 96 1040 is A not less than B ? ;
+#X text 512 1040 --;
+#X text 768 1040 --;
+#X obj 0 1072 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1072 op sin*;
+#X text 96 1072  B * sin(A) in centidegrees ;
+#X text 512 1072 --;
+#X text 768 1072 waves \,  rotations;
+#X obj 0 1104 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1104 op cos*;
+#X text 96 1104  B * cos(A) in centidegrees ;
+#X text 512 1104 --;
+#X text 768 1104 waves \,  rotations;
+#X obj 0 1136 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1136 op atan;
+#X text 96 1136  arctan(A/B) in centidegrees ;
+#X text 512 1136 --;
+#X text 768 1136 find angle to origin (part of polar transform);
+#X obj 0 1168 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1168 op tanh*;
+#X text 96 1168  B * tanh(A) in centidegrees ;
+#X text 512 1168 smooth clipping;
+#X text 768 1168 smooth clipping (of individual points) \,  neural sigmoid, fuzzy logic;
+#X obj 0 1200 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1200 op log*;
+#X text 96 1200  B * log(A) (in base e) ;
+#X text 512 1200 --;
+#X text 768 1200 --;
+#X obj 0 1232 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1232 op gamma;
+#X text 96 1232  floor(pow(a/256.0 \, 256.0/b)*256.0) ;
+#X text 512 1232 gamma correction;
+#X text 768 1232 --;
+#X obj 0 1264 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1264 op **;
+#X text 96 1264  A**B \,  that is, A raised to power B ;
+#X text 512 1264 gamma correction;
+#X text 768 1264 --;
+#X obj 0 1296 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1296 op abs-;
+#X text 96 1296  absolute value of (A-B) ;
+#X text 512 1296 --;
+#X text 768 1296 --;
+#X obj 0 1328 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1328 op rand;
+#X text 96 1328  randomly produces a non-negative number below A ;
+#X text 512 1328 --;
+#X text 768 1328 --;
+#X obj 0 1360 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1360 op sqrt;
+#X text 96 1360  square root of A \,  rounded downwards ;
+#X text 512 1360 --;
+#X text 768 1360 --;
+#X obj 0 1392 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1392 op sq-;
+#X text 96 1392  (A-B) times (A-B) ;
+#X text 512 1392 --;
+#X text 768 1392 --;
+#X obj 0 1424 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1424 op avg;
+#X text 96 1424  (A+B)/2 ;
+#X text 512 1424 --;
+#X text 768 1424 --;
+#X obj 0 1456 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1456 op hypot;
+#X text 96 1456  square root of (A*A+B*B) ;
+#X text 512 1456 --;
+#X text 768 1456 --;
+#X obj 0 1488 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1488 op clip+;
+#X text 96 1488  like A+B but overflow causes clipping instead of wrapping around (coming soon) ;
+#X text 512 1488 --;
+#X text 768 1488 --;
+#X obj 0 1520 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1520 op clip-;
+#X text 96 1520  like A-B but overflow causes clipping instead of wrapping around (coming soon) ;
+#X text 512 1520 --;
+#X text 768 1520 --;
+#X obj 0 1552 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1552 op erf*;
+#X text 96 1552  integral of e^(-x*x) dx ... (coming soon \;  what ought to be the scaling factor?) ;
+#X text 512 1552 --;
+#X text 768 1552 --;
+#X obj 0 1584 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1584 op weight;
+#X text 96 1584  number of "1" bits in an integer;
+#X text 512 1584 --;
+#X text 768 1584 --;
+#X obj 0 1616 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1616 op sin;
+#X text 96 1616 sin(A-B) in radians \,  float only;
+#X text 512 1616 --;
+#X text 768 1616 --;
+#X obj 0 1648 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1648 op cos;
+#X text 96 1648 cos(A-B) in radians \,  float only;
+#X text 512 1648 --;
+#X text 768 1648 --;
+#X obj 0 1680 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1680 op atan2;
+#X text 96 1680 atan2(A \, B) in radians, float only;
+#X text 512 1680 --;
+#X text 768 1680 --;
+#X obj 0 1712 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1712 op tanh;
+#X text 96 1712 tanh(A-B) in radians \,  float only;
+#X text 512 1712 --;
+#X text 768 1712 --;
+#X obj 0 1744 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1744 op exp;
+#X text 96 1744 exp(A-B) in radians \,  float only;
+#X text 512 1744 --;
+#X text 768 1744 --;
+#X obj 0 1776 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1776 op log;
+#X text 96 1776 log(A-B) in radians \,  float only;
+#X text 512 1776 --;
+#X text 768 1776 --;
+#X obj 0 1824 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1824 op C.*    ;
+#X text 96 1824 A*B;
+#X text 512 1824 --;
+#X text 768 1824 --;
+#X obj 0 1856 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1856 op C.*conj;
+#X text 96 1856 A*conj(B);
+#X text 512 1856 --;
+#X text 768 1856 --;
+#X obj 0 1888 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1888 op C./    ;
+#X text 96 1888 A/B;
+#X text 512 1888 --;
+#X text 768 1888 --;
+#X obj 0 1920 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1920 op C./conj;
+#X text 96 1920 A/conj(B);
+#X text 512 1920 --;
+#X text 768 1920 --;
+#X obj 0 1952 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 1952 op C.sq-  ;
+#X text 96 1952 (A-B)*(A-B);
+#X text 512 1952 --;
+#X text 768 1952 --;
+#X obj 0 1984 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 1984 op C.abs- ;
+#X text 96 1984 abs(A-B);
+#X text 512 1984 --;
+#X text 768 1984 --;
+#X obj 0 2016 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 2016 op C.sin  ;
+#X text 96 2016 sin(A-B);
+#X text 512 2016 --;
+#X text 768 2016 --;
+#X obj 0 2048 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 2048 op C.cos  ;
+#X text 96 2048 cos(A-B);
+#X text 512 2048 --;
+#X text 768 2048 --;
+#X obj 0 2080 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 2080 op C.tanh ;
+#X text 96 2080 tanh(A-B);
+#X text 512 2080 --;
+#X text 768 2080 --;
+#X obj 0 2112 cnv 15 1024 30 empty empty empty 20 12 0 14 -249792 -66577 0;
+#X msg 10 2112 op C.exp  ;
+#X text 96 2112 exp(A-B);
+#X text 512 2112 --;
+#X text 768 2112 --;
+#X obj 0 2144 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
+#X msg 10 2144 op C.log  ;
+#X text 96 2144 log(A-B);
+#X text 512 2144 --;
+#X text 768 2144 --;
+#X obj 10 2176 outlet;
+#X obj 95 0 cnv 0 0 2176 empty empty empty -1 12 0 14 0 -66577 0;
+#X obj 511 0 cnv 0 0 2176 empty empty empty -1 12 0 14 0 -66577 0;
+#X obj 767 0 cnv 0 0 2176 empty empty empty -1 12 0 14 0 -66577 0;
+#X obj 0 32 cnv 15 1024 14 empty empty empty 20 12 0 14 -248881 -66577 0;
+#X text 10 32 numops;
+#X obj 0 1808 cnv 15 1024 14 empty empty empty 20 12 0 14 -248881 -66577 0;
+#X text 10 1808 vecops for complex numbers;

Modified: trunk/doc/optable.tcl
==============================================================================
--- trunk/doc/optable.tcl (original)
+++ trunk/doc/optable.tcl Mon Jun 16 13:54:07 2008
@@ -12,7 +12,7 @@
 
 write [list #N canvas 0 0 1024 768 10]
 set y 0
-set i 0
+set row 0
 set oid 0
 set msgboxes {}
 set col1 96
@@ -28,75 +28,96 @@
 incr y 32
 incr oid 5
 
-foreach opdesc {
-{{ignore} { A } {no effect} {no effect} }
-{{put} { B } {replace by} {replace by} }
-{{+} { A + B } {brightness, crossfade} {move, morph} }
-{{-} { A - B } {brightness, motion detection} {move, motion detection} }
-{{inv+} { B - A } {negate then contrast} {180 degree rotate then move} }
-{{*} { A * B } {contrast} {zoom out} }
-{{/} { A / B, rounded towards zero } {contrast} {zoom in} }
-{{div} { A / B, rounded downwards } {contrast} {zoom in} }
-{{inv*} { B / A, rounded towards zero } {--} {--} }
-{{swapdiv} { B / A, rounded downwards } {--} {--} }
-{{%} { A % B, modulo (goes with div) } {--} {tile} }
-{{swap%} { B % A, modulo (goes with div) } {--} {--} }
-{{rem} { A % B, remainder (goes with /) } {--} {--} }
-{{swaprem} { B % A, remainder (goes with /) } {--} {--} }
-{{gcd} {greatest common divisor} {--} {--} }
-{{lcm} {least common multiple} {--} {--} }
-{{|} { A or B, bitwise } {bright munchies} {bottomright munchies} }
-{{^} { A xor B, bitwise } {symmetric munchies (fractal checkers)} {symmetric munchies (fractal checkers)} }
-{{&} { A and B, bitwise } {dark munchies} {topleft munchies} }
-{{<<} { A * (2**(B % 32)), which is left-shifting } {like *} {like *} }
-{{>>} { A / (2**(B % 32)), which is right-shifting } {like /,div} {like /,div} }
-{{||} { if A is zero then B else A } {--} {--} }
-{{&&} { if A is zero then zero else B} {--} {--} }
-{{min} { the lowest value in A,B } {clipping} {clipping (of individual points)} }
-{{max} { the highest value in A,B } {clipping} {clipping (of individual points)} }
-{{cmp} { -1 when A&lt;B; 0 when A=B; 1 when A&gt;B. } {--} {--} }
-{{==} { is A equal to B ? 1=true, 0=false } {--} {--} }
-{{!=} { is A not equal to B ? } {--} {--} }
-{{>} { is A greater than B ? } {--} {--} }
-{{<=} { is A not greater than B ? } {--} {--} }
-{{<} { is A less than B ? } {--} {--} }
-{{>=} {is A not less than B ? } {--} {--} }
-{{sin*} { B * sin(A) in centidegrees } {--} {waves, rotations} }
-{{cos*} { B * cos(A) in centidegrees } {--} {waves, rotations} }
-{{atan} { arctan(A/B) in centidegrees } {--} {find angle to origin (part of polar transform)} }
-{{tanh*} { B * tanh(A) in centidegrees } {smooth clipping} {smooth clipping (of individual points), neural sigmoid, fuzzy logic} }
-{{log*} { B * log(A) (in base e) } {--} {--} }
-{{gamma} { floor(pow(a/256.0,256.0/b)*256.0) } {gamma correction} {--} }
-{{**} { A**B, that is, A raised to power B } {gamma correction} {--} }
-{{abs-} { absolute value of (A-B) } {--} {--} }
-{{rand} { randomly produces a non-negative number below A } {--} {--} }
-{{sqrt} { square root of A, rounded downwards } {--} {--} }
-{{sq-} { (A-B) times (A-B) } {--} {--} }
-{{avg} { (A+B)/2 } {--} {--} }
-{{hypot} { square root of (A*A+B*B) } {--} {--} }
-{{clip+} { like A+B but overflow causes clipping instead of wrapping around (coming soon) } {--} {--} }
-{{clip-} { like A-B but overflow causes clipping instead of wrapping around (coming soon) } {--} {--} }
-{{erf*} { integral of e^(-x*x) dx ... (coming soon; what ought to be the scaling factor?) } {--} {--} }
-{{weight} { number of "1" bits in an integer} {--} {--} }
-{{sin} {sin(A-B) in radians, float only} {--} {--} }
-{{cos} {cos(A-B) in radians, float only} {--} {--} }
-{{atan2} {atan2(A,B) in radians, float only} {--} {--} }
-{{tanh} {tanh(A-B) in radians, float only} {--} {--} }
-{{exp} {exp(A-B) in radians, float only} {--} {--} }
-{{log} {log(A-B) in radians, float only} {--} {--} }
-} {
-	mset {op desc onpixels oncoords} $opdesc
-	if {$i&1} {set bg -233280} {set bg -249792}
-	write [list #X obj 0 $y cnv 15 $col4 30 empty empty empty 20 12 0 14 $bg -66577 0]
+proc op {op desc onpixels oncoords} {
+	global y
+	if {$::row&1} {set bg -233280} {set bg -249792}
+	write [list #X obj 0 $y cnv 15 $::col4 30 empty empty empty 20 12 0 14 $bg -66577 0]
 	write [list #X msg 10 $y op $op]
-	write [list #X text $col1 $y $desc]
-	write [list #X text $col2 $y $onpixels]
-	write [list #X text $col3 $y $oncoords]
-	lappend msgboxes [expr $oid+1]
-	incr i
-	incr y 32
-	incr oid 5
+	write [list #X text $::col1 $y $desc]
+	write [list #X text $::col2 $y $onpixels]
+	write [list #X text $::col3 $y $oncoords]
+	lappend msgboxes [expr $::oid+1]
+	incr ::row
+	incr ::y 32
+	incr ::oid 5
 }
+
+set sections {}
+proc section {desc} {
+	global y
+	lappend ::sections [list $y $desc]
+	incr ::y 16
+}
+
+section {numops}
+op {ignore} { A } {no effect} {no effect}
+op {put} { B } {replace by} {replace by}
+op {+} { A + B } {brightness, crossfade} {move, morph}
+op {-} { A - B } {brightness, motion detection} {move, motion detection}
+op {inv+} { B - A } {negate then contrast} {180 degree rotate then move}
+op {*} { A * B } {contrast} {zoom out}
+op {/} { A / B, rounded towards zero } {contrast} {zoom in}
+op {div} { A / B, rounded downwards } {contrast} {zoom in}
+op {inv*} { B / A, rounded towards zero } {--} {--}
+op {swapdiv} { B / A, rounded downwards } {--} {--}
+op {%} { A % B, modulo (goes with div) } {--} {tile}
+op {swap%} { B % A, modulo (goes with div) } {--} {--}
+op {rem} { A % B, remainder (goes with /) } {--} {--}
+op {swaprem} { B % A, remainder (goes with /) } {--} {--}
+op {gcd} {greatest common divisor} {--} {--}
+op {lcm} {least common multiple} {--} {--}
+op {|} { A or B, bitwise } {bright munchies} {bottomright munchies}
+op {^} { A xor B, bitwise } {symmetric munchies (fractal checkers)} {symmetric munchies (fractal checkers)}
+op {&} { A and B, bitwise } {dark munchies} {topleft munchies}
+op {<<} { A * (2**(B % 32)), which is left-shifting } {like *} {like *}
+op {>>} { A / (2**(B % 32)), which is right-shifting } {like /,div} {like /,div}
+op {||} { if A is zero then B else A } {--} {--}
+op {&&} { if A is zero then zero else B} {--} {--}
+op {min} { the lowest value in A,B } {clipping} {clipping (of individual points)}
+op {max} { the highest value in A,B } {clipping} {clipping (of individual points)}
+op {cmp} { -1 when A&lt;B; 0 when A=B; 1 when A&gt;B. } {--} {--}
+op {==} { is A equal to B ? 1=true, 0=false } {--} {--}
+op {!=} { is A not equal to B ? } {--} {--}
+op {>} { is A greater than B ? } {--} {--}
+op {<=} { is A not greater than B ? } {--} {--}
+op {<} { is A less than B ? } {--} {--}
+op {>=} {is A not less than B ? } {--} {--}
+op {sin*} { B * sin(A) in centidegrees } {--} {waves, rotations}
+op {cos*} { B * cos(A) in centidegrees } {--} {waves, rotations}
+op {atan} { arctan(A/B) in centidegrees } {--} {find angle to origin (part of polar transform)}
+op {tanh*} { B * tanh(A) in centidegrees } {smooth clipping} {smooth clipping (of individual points), neural sigmoid, fuzzy logic}
+op {log*} { B * log(A) (in base e) } {--} {--}
+op {gamma} { floor(pow(a/256.0,256.0/b)*256.0) } {gamma correction} {--}
+op {**} { A**B, that is, A raised to power B } {gamma correction} {--}
+op {abs-} { absolute value of (A-B) } {--} {--}
+op {rand} { randomly produces a non-negative number below A } {--} {--}
+op {sqrt} { square root of A, rounded downwards } {--} {--}
+op {sq-} { (A-B) times (A-B) } {--} {--}
+op {avg} { (A+B)/2 } {--} {--}
+op {hypot} { square root of (A*A+B*B) } {--} {--}
+op {clip+} { like A+B but overflow causes clipping instead of wrapping around (coming soon) } {--} {--}
+op {clip-} { like A-B but overflow causes clipping instead of wrapping around (coming soon) } {--} {--}
+op {erf*} { integral of e^(-x*x) dx ... (coming soon; what ought to be the scaling factor?) } {--} {--}
+op {weight} { number of "1" bits in an integer} {--} {--}
+op {sin} {sin(A-B) in radians, float only} {--} {--}
+op {cos} {cos(A-B) in radians, float only} {--} {--}
+op {atan2} {atan2(A,B) in radians, float only} {--} {--}
+op {tanh} {tanh(A-B) in radians, float only} {--} {--}
+op {exp} {exp(A-B) in radians, float only} {--} {--}
+op {log} {log(A-B) in radians, float only} {--} {--}
+
+section {vecops for complex numbers}
+op {C.*    } {A*B} {--} {--}
+op {C.*conj} {A*conj(B)} {--} {--}
+op {C./    } {A/B} {--} {--}
+op {C./conj} {A/conj(B)} {--} {--}
+op {C.sq-  } {(A-B)*(A-B)} {--} {--}
+op {C.abs- } {abs(A-B)} {--} {--}
+op {C.sin  } {sin(A-B)} {--} {--}
+op {C.cos  } {cos(A-B)} {--} {--}
+op {C.tanh } {tanh(A-B)} {--} {--}
+op {C.exp  } {exp(A-B)} {--} {--}
+op {C.log  } {log(A-B)} {--} {--}
 
 write [list #X obj 10 $y outlet]
 set outletid $oid
@@ -109,3 +130,10 @@
 write [list #X obj [expr $col1-1] 0 cnv 0 0 $y empty empty empty -1 12 0 14 0 -66577 0]
 write [list #X obj [expr $col2-1] 0 cnv 0 0 $y empty empty empty -1 12 0 14 0 -66577 0]
 write [list #X obj [expr $col3-1] 0 cnv 0 0 $y empty empty empty -1 12 0 14 0 -66577 0]
+
+foreach section $sections {
+	mset {y desc} $section
+	write [list #X obj 0 $y cnv 15 $::col4 14 empty empty empty 20 12 0 14 -248881 -66577 0]
+	write [list #X text 10 $y $desc]
+	incr oid 2
+}



More information about the Gridflow-cvs mailing list