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

gridflow-cvs at artengine.ca gridflow-cvs at artengine.ca
Mon Jun 16 16:18:38 EDT 2008


Author: matju
Date: Mon Jun 16 16:18:38 2008
New Revision: 3886

Log:
moved numtype text html->pd

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

Modified: trunk/doc/architecture.html
==============================================================================
--- trunk/doc/architecture.html (original)
+++ trunk/doc/architecture.html Mon Jun 16 16:18:38 2008
@@ -1,26 +1,3 @@
-<h4><a name="Numbers">Numbers</h4>
-High-performance computation requires precise and quite peculiar 
-	definitions of numbers and their representation.
-Inside most programs, numbers are written down as strings of 
-	bits. A bit is either zero or one. Just like the decimal system 
-	uses units, tens, hundreds, the binary system uses units, twos, 
-	fours, eights, sixteens, and so on, doubling every time.
-One notation, called integer allows for only integer values to be 
-	written (no fractions). when it is unsigned, no negative values may 
-	be written. when it is signed, one bit indicates whether the number 
-	is positive or negative. Integer storage is usually fixed-size, so you have 
-	bounds on the size of numbers, and if a result is too big it "wraps around", truncating the biggest 
-	bits.
-Another notation, called floating point (or float) stores numbers using 
-	a fixed number of significant digits, and a scale factor that allows for huge numbers 
-	and tiny fractions at once. Note that 1/3 has periodic digits, but even 0.1 has periodic digits, 
-	in binary coding; so expect some slight roundings; the precision offered should be 
-	sufficient for most purposes. Make sure the errors of rounding don't accumulate, though.
-This little program of mine prints 1/3 in base 2 (only digits after the period): ruby -e 'x=1/3.0;for i in 0..52 do x*=2;y=x.floor;print y;x-=y end;puts'
-In GridFlow, there are six kinds of numbers:
-<table bgcolor="black" border="0" cellspacing="1">
-<td align="left" valign="top"><table bgcolor="white" border="0" cellpadding="4" cellspacing="1">
-
 <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:18:38 2008
@@ -4,9 +4,9 @@
 
 proc write {list} {
 	set v [join $list " "]
-	regsub "," $v " \\, " v
-	regsub ";" $v " \\; " v
-	regsub "\\$" $v "\\$" v
+	regsub -all "," $v " \\, " v
+	regsub -all ";" $v " \\; " v
+	regsub -all "\\$" $v "\\$" v
 	puts $::fh "$v;"
 }
 
@@ -164,6 +164,14 @@
 set col4 1024
 set rowsize 64
 
+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 names]
+write [list #X text $col1 $y range]
+write [list #X text $col2 $y precision]
+write [list #X text $col3 $y description]
+incr y 32
+incr oid 5
+
 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.)}
@@ -177,4 +185,24 @@
 
 draw_columns
 
+proc p {text} {write [list #X text 10 $::y $text]; incr ::y 60}
+
+p {High-performance computation requires precise and quite peculiar
+	definitions of numbers and their representation.}
+p {Inside most programs, numbers are written down as strings of 
+	bits. A bit is either zero or one. Just like the decimal system 
+	uses units, tens, hundreds, the binary system uses units, twos, 
+	fours, eights, sixteens, and so on, doubling every time.}
+p {One notation, called integer allows for only integer values to be 
+	written (no fractions). when it is unsigned, no negative values may 
+	be written. when it is signed, one bit indicates whether the number 
+	is positive or negative. Integer storage is usually fixed-size, so you have 
+	bounds on the size of numbers, and if a result is too big it "wraps around", truncating the biggest 
+	bits.}
+p {Another notation, called floating point (or float) stores numbers using 
+	a fixed number of significant digits, and a scale factor that allows for huge numbers 
+	and tiny fractions at once. Note that 1/3 has periodic digits, but even 0.1 has periodic digits, 
+	in binary coding; so expect some slight roundings; the precision offered should be 
+	sufficient for most purposes. Make sure the errors of rounding don't accumulate, though.}
+
 close $fh

Modified: trunk/doc/numop.pd
==============================================================================
--- trunk/doc/numop.pd (original)
+++ trunk/doc/numop.pd Mon Jun 16 16:18:38 2008
@@ -113,7 +113,7 @@
 #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 96 848  -1 when A&lt \; B \;  0 when A=B \;  1 when A&gt \; B. ;
 #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 ;
@@ -151,7 +151,7 @@
 #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 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) ;
@@ -161,7 +161,7 @@
 #X text 512 1232 gamma correction;
 #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 96 1264  A**B \,  that is \,  A raised to power B ;
 #X text 512 1264 gamma correction;
 #X obj 0 1296 cnv 15 1024 30 empty empty empty 20 12 0 14 -233280 -66577 0;
 #X msg 10 1296 op abs-;
@@ -201,7 +201,7 @@
 #X text 96 1648 cos(A-B) in radians \,  float only;
 #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 96 1680 atan2(A \, B) in radians \,  float only;
 #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;

Modified: trunk/doc/numtype.pd
==============================================================================
--- trunk/doc/numtype.pd (original)
+++ trunk/doc/numtype.pd Mon Jun 16 16:18:38 2008
@@ -1,34 +1,68 @@
-#N canvas 0 0 1024 768 10;
-#X obj 0 0 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 0 op b  u8   uint8;
-#X text 192 0 0 to 255;
-#X text 384 0 1;
-#X text 608 0 
-	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.);
-#X obj 0 64 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 64 op s i16   int16;
-#X text 192 64 -32768 to 32767;
-#X text 384 64 1;
-#X obj 0 128 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 128 op i i32   int32;
-#X text 192 128 -(1<<31) to (1<<31)-1;
-#X text 384 128 1;
-#X text 608 128 
-	signed 32-bit integer. this is used by default throughout GridFlow.
-;
-#X obj 0 192 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 192 op l i64   int64;
-#X text 192 192 -(1<<63) to (1<<63)-1;
-#X text 384 192 1;
-#X obj 0 256 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577 0;
-#X msg 10 256 op f f32 float32;
-#X text 192 256 -(1<<128) to (1<<128);
-#X text 384 256 23 bits or 0.000012%;
-#X obj 0 320 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577 0;
-#X msg 10 320 op d f64 float64;
-#X text 192 320 -(1<<2048) to (1<<2048);
-#X text 384 320 52 bits or 0.000000000000022%;
-#X obj 191 0 cnv 0 0 384 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 383 0 cnv 0 0 384 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 607 0 cnv 0 0 384 empty empty empty -1 12 0 14 0 -66577 0;
+#N canvas 0 0 1024 689 10;
+#X obj 0 0 cnv 15 1024 30 empty empty empty 20 12 0 14 -195568 -66577
+0;
+#X text 10 0 op names;
+#X text 192 0 range;
+#X text 384 0 precision;
+#X text 608 0 description;
+#X obj 0 32 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
+#X msg 10 32 op b u8 uint8;
+#X text 192 32 0 to 255;
+#X text 384 32 1;
+#X text 608 32 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.);
+#X obj 0 96 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577
+0;
+#X msg 10 96 op s i16 int16;
+#X text 192 96 -32768 to 32767;
+#X text 384 96 1;
+#X obj 0 160 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
+#X msg 10 160 op i i32 int32;
+#X text 192 160 -(1<<31) to (1<<31)-1;
+#X text 384 160 1;
+#X text 608 160 signed 32-bit integer. this is used by default throughout
+GridFlow.;
+#X obj 0 224 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577
+0;
+#X msg 10 224 op l i64 int64;
+#X text 192 224 -(1<<63) to (1<<63)-1;
+#X text 384 224 1;
+#X obj 0 288 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
+#X msg 10 288 op f f32 float32;
+#X text 192 288 -(1<<128) to (1<<128);
+#X text 384 288 23 bits or 0.000012%;
+#X obj 0 352 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577
+0;
+#X msg 10 352 op d f64 float64;
+#X text 192 352 -(1<<2048) to (1<<2048);
+#X text 384 352 52 bits or 0.000000000000022%;
+#X obj 191 0 cnv 1 1 416 empty empty empty -1 12 0 14 -262144 -66577
+0;
+#X obj 383 0 cnv 1 1 416 empty empty empty -1 12 0 14 -262144 -66577
+0;
+#X obj 607 0 cnv 1 1 416 empty empty empty -1 12 0 14 -262144 -66577
+0;
+#X text 10 436 High-performance computation requires precise and quite
+peculiar definitions of numbers and their representation.;
+#X text 10 486 Inside most programs \, numbers are written down as
+strings of bits. A bit is either zero or one. Just like the decimal
+system uses units \, tens \, hundreds \, the binary system uses units
+\, twos \, fours \, eights \, sixteens \, and so on \, doubling every
+time.;
+#X text 540 436 One notation \, called integer allows for only integer
+values to be written (no fractions). when it is unsigned \, no negative
+values may be written. when it is signed \, one bit indicates whether
+the number is positive or negative. Integer storage is usually fixed-size
+\, so you have bounds on the size of numbers \, and if a result is
+too big it "wraps around" \, truncating the biggest bits.;
+#X text 540 546 Another notation \, called floating point (or float)
+stores numbers using a fixed number of significant digits \, and a
+scale factor that allows for huge numbers and tiny fractions at once.
+Note that 1/3 has periodic digits \, but even 0.1 has periodic digits
+\, in binary coding \; so expect some slight roundings \; the precision
+offered should be sufficient for most purposes. Make sure the errors
+of rounding don't accumulate \, though.;



More information about the Gridflow-cvs mailing list