[Gridflow-cvs] [svn] commit: r3882 - in /trunk/doc: Makefile architecture.html moulinette.tcl optable.tcl

gridflow-cvs at artengine.ca gridflow-cvs at artengine.ca
Mon Jun 16 14:56:00 EDT 2008


Author: matju
Date: Mon Jun 16 14:56:00 2008
New Revision: 3882

Log:
renamed optable.tcl to moulinette.tcl

Added:
    trunk/doc/moulinette.tcl
Removed:
    trunk/doc/optable.tcl
Modified:
    trunk/doc/Makefile
    trunk/doc/architecture.html

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

Modified: trunk/doc/architecture.html
==============================================================================
--- trunk/doc/architecture.html (original)
+++ trunk/doc/architecture.html Mon Jun 16 14:56:00 2008
@@ -1,124 +1,92 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head><!-- $Id$ -->
-<title>GridFlow 0.9.3 - Reference Manual: Architecture</title><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<link rel="stylesheet" href="gridflow.css" type="text/css"></head><body leftmargin="0" topmargin="0" bgcolor="#ffffff" marginheight="0" marginwidth="0">
-
-<table width="100%" cellspacing="10">
-<tr><td>
-<table width="100%" border="0" cellspacing="0" cellpadding="0">
-<tr>
-  <td>             <img src="images/header1.png" alt="GridFlow" width="384"  height="64"></td>
-  <td width="100%"><img src="images/header2.png" alt="GridFlow" width="100%" height="64"></td>
-  <td>             <img src="images/header3.png" alt="GridFlow" width="32"   height="64"></td>
-</table>
-</td></tr></table>
-<blockquote>
-
-<table bgcolor="white" border="0" cellspacing="2" width="100%">
-<tr><td bgcolor="black"><img src="images/black.png" height="2" width="1"></td></tr>
-
-<tr><td height="16"><h4>GridFlow 0.9.3 - Reference Manual: Architecture</h4>
-<ul>
-<li><a href="#Numbers">Numbers</a>
-<li><a href="#Grid_Literals">Grid Literals</a>
-<li><a href="#Grid_Protocol">Grid Protocol</a>
-<li><a href="#Picture_Protocol">Picture Protocol</a>
-<li><a href="#Numeric_Operators">Numeric Operators</a>
-<li><a href="#Synchronisation">Synchronisation</a>
-<li><a href="#Bridges">Bridges</a>
-</ul>
-<br></td></tr>
-<tr><td bgcolor="black"><img src="images/black.png" height="2" width="1"></td></tr>
-
-<tr><td><h4><a name="Numbers">Numbers</a></h4>
-<p>High-performance computation requires precise and quite peculiar 
-	definitions of numbers and their representation.</p>
-<p>Inside most programs, numbers are written down as strings of 
+<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.</p>
-<p>One notation, called integer allows for only integer values to be 
+	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.</p>
-<p>Another notation, called floating point (or float) stores numbers using 
+	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.</p>
-<p>This little program of mine prints 1/3 in base 2 (only digits after the period): <kbd>ruby -e 'x=1/3.0;for i in 0..52 do x*=2;y=x.floor;print y;x-=y end;puts'</kbd></p>
-<p>In GridFlow, there are six kinds of numbers:</p>
+	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">
-<tr><td align="left" valign="top"><table bgcolor="white" border="0" cellpadding="4" cellspacing="1">
-<tr>
-<td class="c3"><b>name</b></td>
-<td class="c3"><b>aliases</b></td>
-<td class="c3"><b>range</b></td>
-<td class="c3"><b>size (bytes)</b></td>
-<td class="c3"><b>precision</b></td>
-<td class="c3"><b>description</b></td></tr>
-<tr class="c1"><td>uint8</td><td>u8 b</td><td>0..255</td><td>1</td><td>1</td><td> 
+<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 <kbd>int32</kbd>
-			unless otherwise specified.) </td></tr> 
-<tr class="c2"><td>int16</td><td>i16 s</td><td>±2<sup>15</sup> = -32768..32767</td><td>2</td><td>1</td><td>...</td></tr> 
-<tr class="c1"><td>int32</td><td>i32 i</td><td>±2<sup>31</sup> = -2147483648..2147483647</td><td>4</td><td>1</td><td> 
+			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. </td></tr> 
-<tr class="c2"><td>int64</td><td>i64 l</td><td>±2<sup>63</sup></td><td>8</td><td>1</td><td>...</td></tr> 
-<tr class="c1"><td>float32</td><td>f32 f</td><td>±10<sup>±38</sup></td><td>4</td><td>23 bits = 0.000012% (about 7 digits)</td><td>...</td></tr> 
-<tr class="c2"><td>float64</td><td>f64 d</td><td>±10<sup>±308</sup></td><td>8</td><td>52 bits (about 15 digits)</td><td>...</td></tr> </table></td></tr></table></td></tr>
+			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)... 
  
-<tr><td bgcolor="black"><img src="images/black.png" height="2" width="1"></td></tr>
-<tr><td><h4><a name="Grid_Literals">Grid Literals</a></h4>
-<p>	In every grid-accepting inlet, a list may be sent instead; if 
+<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 
 	it consists only of integers, it will be converted to a 
 	one-dimensional grid. Else it may contain a single "#" sign and 
 	integers on both sides of it, where the ones to the left of it are 
-	fed as arguments to an imaginary <kbd>[#redim]</kbd> object and the one to the 
-	right of it are fed through that <kbd>[#redim]</kbd>. </p>
-<p> 	In every grid-accepting inlet, an integer or float may also be sent; 
-	it will be converted to a zero-dimensional grid (a <b>scalar</b>). </p></td></tr>
+	fed as arguments to an imaginary [#redim] object and the one to the 
+	right of it are fed through that [#redim]. 
+ 	In every grid-accepting inlet, an integer or float may also be sent; 
+	it will be converted to a zero-dimensional grid (a scalar). 
 
 
-<tr><td bgcolor="black">
-<img src="images/black.png" height="2" width="1"></td></tr>
+<td bgcolor="black">
+<img src="images/black.png" height="2" width="1">
 
-<tr><td><h4><a name="Grid_Protocol">Grid Protocol</a></h4>
-<p>	a grid has an associated number type that defines what are the possible values for its elements 
-	(and how much space it takes). the default is <b>int32</b>. </p>
-<p>	a single-dimensional grid of 3 elements (a triplet) is called dim(3). a 
+<h4><a name="Grid_Protocol">Grid Protocol</h4>
+	a grid has an associated number type that defines what are the possible values for its elements 
+	(and how much space it takes). the default is int32. 
+	a single-dimensional grid of 3 elements (a triplet) is called dim(3). a 
 	three-dimensional grid of 240 rows of 320 columns of triplets is called 
-	dim(240,320,3). </p>
-<p> 	There is a sequence in which elements of a Grid are stored and 
+	dim(240,320,3). 
+ 	There is a sequence in which elements of a Grid are stored and 
 	transmitted.  Dimension 0 is called "first" and dimension N-1 is 
 	called "last". They are called so because if you select a 
 	position in the first dimension of a grid, the selected part is of the same 
 	shape minus the first dimension; so in dim(240,320,3) if you select 
 	row 51 (or whichever valid row number), you get a dim(320,3). if you select 
-	a subpart two more times you get to a single number. </p>
-<p> 	At each such level, elements are sent/stored in their numeric order, 
+	a subpart two more times you get to a single number. 
+ 	At each such level, elements are sent/stored in their numeric order, 
 	and are numbered using natural numbers starting at 0. This ordering usually 
-	does not matter, but sometimes it does. Most notably, <kbd>[#import]</kbd>, <kbd>[#export]</kbd> and <kbd>[#redim]</kbd> care about it. </p>
-<p>	On the other hand, order of dimensions usually does matter; this is 
+	does not matter, but sometimes it does. Most notably, [#import], [#export] and [#redim] care about it. 
+	On the other hand, order of dimensions usually does matter; this is 
 	what distinguishes rows from columns and channels, for example. 
-	Most objects care about the distinction. </p>
-<p>	A grid with only 1 element in a given dimension is different from one 
+	Most objects care about the distinction. 
+	A grid with only 1 element in a given dimension is different from one 
 	lacking that dimension; it won't have the same meaning. You can use this 
-	property to your advantage sometimes. </p>
-<p>	Zero-dimensional grids exist. They are called dim(). They can only contain 
-	a single number. </p>
-<tr><td bgcolor="black">
-<img src="images/black.png" height="2" width="1"></td></tr>
-<tr><td><h4><a name="Picture_Protocol">Picture Protocol</a></h4>
-<p><i>This section is useful if you want to know what a picture is in terms of a grid. </i></p>
-<p>A picture is a three-dimensional Grid: </p><ul> <li><b>0</b> : rows</li> <li><b>1</b> : columns</li> <li><b>2</b> : channels</li> </ul>
+	property to your advantage sometimes. 
+	Zero-dimensional grids exist. They are called dim(). They can only contain 
+	a single number. 
+<td bgcolor="black">
+<img src="images/black.png" height="2" width="1">
+<h4><a name="Picture_Protocol">Picture Protocol</h4>
+<i>This section is useful if you want to know what a picture is in terms of a grid. </i>
+A picture is a three-dimensional Grid:  0 : rows</li> 1 : columns</li> 2 : channels</li> 
 
-<p>Channels for the RGB color model are: </p><ul> <li><b>0</b> : red</li> <li><b>1</b> : green</li> <li><b>2</b> : blue</li> </ul>
-<p> 	Because Grids are made of 32-bit integers, a three-channel picture uses 
+Channels for the RGB color model are:  0 : red</li> 1 : green</li> 2 : blue</li> 
+ 	Because Grids are made of 32-bit integers, a three-channel picture uses 
 	96 bpp (bits per pixel), and have to be downscaled to 24 bpp (or 16 bpp) 
 	for display. That huge amount of slack is there because when you create 
 	your own effects you often have intermediate results that need to be of 
@@ -126,67 +94,31 @@
 	are big and should not overflow before you divide them back to normal; 
 	and similarly, you can have negative values all over, as long as you take 
 	care of them before they get to the display.
-<p> 	In the final conversion, high bits are just ignored. This means: black is 
-	0, maximum is 255, and values wrap like with <kbd>% 256</kbd>. If you want to 
-	clip them, you may use <kbd>[# max 0]</kbd> and <kbd>[# min 255]</kbd> objects.
+ 	In the final conversion, high bits are just ignored. This means: black is 
+	0, maximum is 255, and values wrap like with % 256. If you want to 
+	clip them, you may use [# max 0] and [# min 255] objects.
 
-<tr><td bgcolor="black"><img src="images/black.png" height="2" width="1"></td></tr>
-<tr><td><h4><a name="Numeric_Operators">Numeric Operators</a></h4></td></tr>
-<tr><td><p>In the following table, A is the value entered to the 
-		left, and B is the value entered to the right.</p></td></tr>
-<tr><td><p>Angles are in hundredths of degrees. This means a full circle 
+<h4><a name="Numeric_Operators">Numeric Operators</h4>
+In the following table, A is the value entered to the 
+		left, and B is the value entered to the right.
+Angles are in hundredths of degrees. This means a full circle 
 		(two pi radians) is 36000. You convert from degrees to our angles 
 		by multiplying by 100. You convert from radians to our angles by 
-		multiplying by 18000/pi.</p></td></tr>
-<tr><td><p>Hyperbolic functions (tanh) work with our angles too, so the 
-		same conversions apply.</p></td></tr>
+		multiplying by 18000/pi.
+Hyperbolic functions (tanh) work with our angles too, so the same conversions apply.
 
-<tr><td><table bgcolor="black" border="0" cellspacing="1">
-<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 pixel context (pictures, palettes)</b></td><td><b>meaning in spatial context (indexmaps, polygons)</b></td></tr>
+The following are called VecOps because each operation happens between more than just two numbers.
+A first kind of VecOp are those that arise when a pair of numbers (A0,A1) is considered as a single number A0+A1*sqrt(-1).
+If you need complex numbers but don't know yet how they work, learn them using a math tutorial and then those VecOps will begin to seem familiar.
+All the complex number operators are only for floats.
+TODO: fill the last two columns of this table.
 
-<p>The following are called VecOps because each operation happens between more than just two numbers.</p>
-<p>A first kind of VecOp are those that arise when a pair of numbers (A0,A1) is considered as a single number A0+A1*sqrt(-1).
-If you need complex numbers but don't know yet how they work, learn them using a math tutorial and then those VecOps will begin to seem familiar.</p>
-<p>All the complex number operators are only for floats.</p>
-<p>TODO: fill the last two columns of this table.</p>
 
-<tr><td><table bgcolor="black" border="0" cellspacing="1">
-<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>
 
-</table></td></tr></table></td></tr>
-
-<tr><td bgcolor="black">
-<img src="images/black.png" height="2" width="1"></td></tr>
-
-<tr><td><h4><a name="Synchronisation">Synchronisation</a></h4>
-<p>In GridFlow you cannot send two grids in different inlets at the 
-same time. You have to use <kbd>[#finished]</kbd> together with (possibly) <kbd>[fork]</kbd> and <kbd>[#store]</kbd>, 
+<h4><a name="Synchronisation">Synchronisation</h4>
+In GridFlow you cannot send two grids in different inlets at the 
+same time. You have to use [#finished] together with (possibly) [fork] and [#store], 
 which can be cumbersome. If you don't do this, the result is undefined 
-behaviour (or crash!).</p>
-<p>In GridFlow 0.7.1 this is beginning to change. <kbd>[#store]</kbd> and # now allow 
-right-inlet grids to be buffered if an operation is occuring on left inlet. This 
-should make many circuits simpler. </p>
-<p>(more to come)</p>
-<tr><td bgcolor="black"><img src="images/black.png" height="2" width="1"></td></tr>
-
-<tr><td><h4><a name="Bridges">Bridges</a></h4>
-<p>Starting with GridFlow 0.6, GridFlow comes
-with a bridge (a converter) between Ruby and Pd.
-During the GridFlow 0.9 series, GridFlow will be made to work directly with Pd instead.
-Thus Ruby will become optional and essentially separate from GridFlow.
-</p></td></tr>
-
-<tr><td bgcolor="black">
-<img src="images/black.png" height="2" width="1"></td></tr>
-
-<tr><td>
-<p><font size="-1">
-GridFlow 0.9.3 Documentation<br>
-Copyright © 2001-2008 by Mathieu Bouchard
-<a href="mailto:matju at artengine.ca">matju at artengine.ca</a>
-</p>
-</font>
-</td></tr></table>
-</blockquote></body></html>
+behaviour (or crash!).
+There are two exceptions: [#store] and # allow right-inlet grids to be buffered if an operation is occuring on left inlet. This 
+should make many programs simpler. 



More information about the Gridflow-cvs mailing list