[Gridflowcvs] [svn] commit: r3882  in /trunk/doc: Makefile architecture.html moulinette.tcl optable.tcl
gridflowcvs at artengine.ca
gridflowcvs 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 httpequiv="ContentType" content="text/html; charset=ISO88591">
<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>Highperformance 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>
+Highperformance 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 fixedsize, 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 8bit 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 32bit 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 gridaccepting 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 gridaccepting inlet, a list may be sent instead; if
it consists only of integers, it will be converted to a
onedimensional 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 gridaccepting inlet, an integer or float may also be sent;
 it will be converted to a zerodimensional 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 gridaccepting inlet, an integer or float may also be sent;
+ it will be converted to a zerodimensional 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 singledimensional 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 singledimensional grid of 3 elements (a triplet) is called dim(3). a
threedimensional 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 N1 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> Zerodimensional 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 threedimensional 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.
+ Zerodimensional 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 threedimensional 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 32bit integers, a threechannel picture uses
+Channels for the RGB color model are: 0 : red</li> 1 : green</li> 2 : blue</li>
+ Because Grids are made of 32bit integers, a threechannel 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
rightinlet 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 © 20012008 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 rightinlet grids to be buffered if an operation is occuring on left inlet. This
+should make many programs simpler.
More information about the Gridflowcvs
mailing list