[Gridflow-cvs] [svn] commit: r5756 - in /trunk/doc: moulinette.tcl numtype.pd

svn-gridflow at artengine.ca svn-gridflow at artengine.ca
Thu Jul 22 21:31:56 EDT 2010


Author: matju
Date: Thu Jul 22 21:31:55 2010
New Revision: 5756

Log:
numtype.pd will be no longer generated.

Modified:
    trunk/doc/moulinette.tcl
    trunk/doc/numtype.pd

Modified: trunk/doc/moulinette.tcl
==============================================================================
--- trunk/doc/moulinette.tcl (original)
+++ trunk/doc/moulinette.tcl Thu Jul 22 21:31:55 2010
@@ -43,7 +43,8 @@
 	if {$::row&1} {set bg -233280} {set bg -249792}
 	obj 0 $y cnv 15 $::col4 [expr $::rowsize-2] empty empty empty 20 12 0 14 $bg -66577 0
 	lappend ::msgboxes $::oid
-	msg 10 $y op $op
+	set x 10
+	foreach op1 $op {msg $x $y op $op; incr 50}
 	text $::col1 $y $desc
 	if {$extra1 != ""} {text $::col2 $y $extra1}
 	if {$extra2 != ""} {text $::col3 $y $extra2}
@@ -164,53 +165,4 @@
 }
 
 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
 
-obj 0 $y cnv 15 $col4 30 empty empty empty 20 12 0 14 20 -66577 0
-text 10 $y op names
-text $col1 $y range
-text $col2 $y precision
-text $col3 $y description
-incr y 32
-
-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
-
-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/numtype.pd
==============================================================================
--- trunk/doc/numtype.pd (original)
+++ trunk/doc/numtype.pd Thu Jul 22 21:31:55 2010
@@ -1,56 +1,74 @@
-#N canvas 0 0 1024 768 10;
-#X obj 0 0 cnv 15 1024 30 empty empty empty 20 12 0 14 20 -66577 0;
+#N canvas 0 0 1024 717 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 obj 0 32 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
 #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 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 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 obj 0 160 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
 #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 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 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 obj 0 288 cnv 15 1024 62 empty empty empty 20 12 0 14 -249792 -66577
+0;
 #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 obj 0 352 cnv 15 1024 62 empty empty empty 20 12 0 14 -233280 -66577
+0;
 #X text 192 352 -(1<<2048) to (1<<2048);
 #X text 384 352 52 bits or 0.000000000000022%;
-#X obj 191 0 cnv 0 0 416 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 383 0 cnv 0 0 416 empty empty empty -1 12 0 14 0 -66577 0;
-#X obj 607 0 cnv 0 0 416 empty empty empty -1 12 0 14 0 -66577 0;
-#X text 10 416 High-performance computation requires precise and quite peculiar
-	definitions of numbers and their representation.;
-#X text 10 476 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 10 536 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 10 596 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.;
+#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 416 High-performance computation requires precise and quite
+peculiar definitions of numbers and their representation.;
+#X text 10 476 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 10 536 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 10 596 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.;
+#X msg 10 96 cast s;
+#X msg 10 32 cast b;
+#X msg 10 160 cast i;
+#X msg 14 226 cast l;
+#X msg 10 288 cast f;
+#X msg 10 352 cast d;
+#X msg 60 32 cast uint8;
+#X msg 60 96 cast int16;
+#X msg 60 160 cast int32;
+#X msg 60 224 cast int64;
+#X msg 60 288 cast float32;
+#X msg 60 352 cast float64;



More information about the Gridflow-cvs mailing list