[Gridflow-cvs] [svn] commit: r3885 - in /trunk/doc: Makefile architecture.html moulinette.tcl numop.pd numtype.pd

gridflow-cvs at artengine.ca gridflow-cvs at artengine.ca
Mon Jun 16 16:08:24 EDT 2008


Author: matju
Date: Mon Jun 16 16:08:24 2008
New Revision: 3885

Log:
numtype table html->pd

Added:
    trunk/doc/numtype.pd
Modified:
    trunk/doc/Makefile
    trunk/doc/architecture.html
    trunk/doc/moulinette.tcl
    trunk/doc/numop.pd

Modified: trunk/doc/Makefile
==============================================================================
--- trunk/doc/Makefile (original)
+++ trunk/doc/Makefile Mon Jun 16 16:08:24 2008
@@ -1,7 +1,7 @@
-all:: index.pd numop.pd numbertype.pd
+all:: index.pd numop.pd numtype.pd
 
 index.pd: make_index.tcl locale/english.tcl
 	tclsh make_index.tcl > index.pd
 
-numop.pd numbertype.pd: moulinette.tcl
+numop.pd numtype.pd: moulinette.tcl
 	tclsh moulinette.tcl

Modified: trunk/doc/architecture.html
==============================================================================
--- trunk/doc/architecture.html (original)
+++ trunk/doc/architecture.html Mon Jun 16 16:08:24 2008
@@ -21,25 +21,6 @@
 <table bgcolor="black" border="0" cellspacing="1">
 <td align="left" valign="top"><table bgcolor="white" border="0" cellpadding="4" cellspacing="1">
 
-name
-aliases
-range
-size (bytes)
-precision
-description
-uint8u8 b0..25511 
-			unsigned 8-bit integer. 
-			this is the usual size of numbers taken from files and cameras, and 
-			written to files and to windows. (however this gets converted to int32
-			unless otherwise specified.)  
-int16i16 s±2<sup>15</sup> = -32768..3276721... 
-int32i32 i±2<sup>31</sup> = -2147483648..214748364741 
-			signed 32-bit integer. 
-			this is used for most computations.  
-int64i64 l±2<sup>63</sup>81... 
-float32f32 f±10<sup>±38</sup>423 bits = 0.000012% (about 7 digits)... 
-float64f64 d±10<sup>±308</sup>852 bits (about 15 digits)... 
- 
 <td bgcolor="black"><img src="images/black.png" height="2" width="1">
 <h4><a name="Grid_Literals">Grid Literals</h4>
 	In every grid-accepting inlet, a list may be sent instead; if 

Modified: trunk/doc/moulinette.tcl
==============================================================================
--- trunk/doc/moulinette.tcl (original)
+++ trunk/doc/moulinette.tcl Mon Jun 16 16:08:24 2008
@@ -20,6 +20,7 @@
 set col2 512
 set col3 768
 set col4 1024
+set rowsize 32
 
 write [list #X obj 0 $y cnv 15 $col4 30 empty empty empty 20 12 0 14 20 -66577 0]
 write [list #X text 10 $y op name]
@@ -35,19 +36,27 @@
 # for vecops, the two analogy-columns were labelled:
 #   meaning in geometric context (indexmaps, polygons, in which each complex number is a point)
 #   meaning in spectrum context (FFT) in which each number is a (cosine,sine) pair
-proc op {op desc onpixels oncoords} {
+proc op {op desc {extra1 ""} {extra2 ""}} {
 	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 obj 0 $y cnv 15 $::col4 [expr $::rowsize-2] 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]
+	if {$extra1 != ""} {write [list #X text $::col2 $y $extra1]}
+	if {$extra2 != ""} {write [list #X text $::col3 $y $extra2]}
 	lappend msgboxes [expr $::oid+1]
 	incr ::row
-	incr ::y 32
+	incr ::y $::rowsize
 	incr ::oid 5
 }
+
+proc draw_columns {} {
+	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]
+}
+
+proc numbertype {op desc {extra1 ""} {extra2 ""}} {op $op $desc $extra1 $extra2}
 
 set sections {}
 proc section {desc} {
@@ -65,66 +74,66 @@
 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 {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 {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 {||} { 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 {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} {--} {--}
+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)} {--} {--}
+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
@@ -134,9 +143,7 @@
 	write [list #X connect $msgbox 0 $outletid 0]
 }
 
-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]
+draw_columns
 
 foreach section $sections {
 	mset {y desc} $section
@@ -146,3 +153,28 @@
 }
 
 close $fh
+set fh [open numtype.pd w]
+write [list #N canvas 0 0 1024 768 10]
+set y 0
+set row 0
+set oid 0
+set col1 192
+set col2 384
+set col3 608
+set col4 1024
+set rowsize 64
+
+numbertype {b  u8   uint8} {0 to 255} {1} {
+	unsigned 8-bit integer. this is the usual size of numbers taken from files and cameras, and
+	written to files and to windows. (however #in converts to int32 unless otherwise specified.)}
+numbertype {s i16   int16} {-32768 to 32767} {1}
+numbertype {i i32   int32} {-(1<<31) to (1<<31)-1} {1} {
+	signed 32-bit integer. this is used by default throughout GridFlow.
+}
+numbertype {l i64   int64} {-(1<<63) to (1<<63)-1} {1}
+numbertype {f f32 float32} {-(1<<128) to (1<<128)} {23 bits or 0.000012%}
+numbertype {d f64 float64} {-(1<<2048) to (1<<2048)} {52 bits or 0.000000000000022%}
+
+draw_columns
+
+close $fh

Modified: trunk/doc/numop.pd
==============================================================================
--- trunk/doc/numop.pd (original)
+++ trunk/doc/numop.pd Mon Jun 16 16:08:24 2008
@@ -47,13 +47,9 @@
 #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) ;
@@ -62,28 +58,18 @@
 #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 ;
@@ -112,13 +98,9 @@
 #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 ;
@@ -132,38 +114,24 @@
 #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 ;
@@ -187,153 +155,95 @@
 #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;



More information about the Gridflow-cvs mailing list