




Date: Sat, 07 Jun 1997 10:22:39 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Origami data structure

One of the most difficult parts of writing an origami computer program is
the problem of how to represent the paper so that it can be operated on
and interpreted for diagrams.

I'm interested in people's thoughts on this problem.

Representing the crease pattern is easy. Just use the coordinates of the
endpoints of lines and so on. The real difficulty, it seems to me, is how
to represent the complex layering that occurs in folding.

One solution, of course, is to use an absolute coordinate system, and
paper that has thickness. That way, the thickness of the paper will cause
layers to be inherent, by virtue of the fact that they have a certain
distance and direction from their neighboring layers.

The problem with that approach, is that it doesn't answer the question of
how to make use of those layers. In other words, the layers themselves are
implicit in the structure, but very difficult to operate on. The program's
functions themselves will have to do all the work of calculating the
layers from the data. So what this solution does is just shift the problem
from data to function. But the actual problem itself remains unsolved (I
hope that's clear, or at least, that I'm wrong). Even if the functions
did get written, they would be terribly inefficient, having to
recalculate layers over and over again with computation-intensive
processes (or else store the layer data somewhere, and what would that
data structure look like?)

So that's where I have gotten on the problem. From what I can gather, and
the people I've shown it to, it's a real toughie. Maybe we can solve it
together.

Zack

p.s.: as a side topic, how many people on this list have memorized a
model to the point where they can see the square in the model? I can with
the flapping bird, and I remember being very excited when I realized it.





Date: Sat, 07 Jun 1997 10:41:20 -0300 (ADT)
From: candice bradley/daniel byrne <candice@samara.co.zw>
Subject: Re: Origami data structure

Zachary Brown wrote:
>
> One of the most difficult parts of writing an origami computer program > is
     the problem of how to represent the paper so that it can be > operated on
     and interpreted for diagrams.

I would like to know what origami computer programs are available, where
to get them, and if any can be downloaded off the internet.

Candice Bradley





Date: Sat, 07 Jun 1997 11:27:34 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Re: Origami data structure

> I would like to know what origami computer programs are available, where
> to get them, and if any can be downloaded off the internet.

ftp://rugcis.rug.nl/origami/ is a good place to start. That should have
it all.

Zack

> Candice Bradley





Date: Sat, 07 Jun 1997 14:52:42 -0300 (ADT)
From: Rjlang@aol.com
Subject: Re: Bird base patterns.

> I find interesting is that the missing numbers in this sequence --
> 4, 6, 7, 8 equal points -- result in very interesting and elegant,
> but previously little- or un-known bases, some of which are quite
> useful.

Sorry for the typo: _4_ equal points leads to the Bird Base, of course. It's
_3_ equal points that leads to a base based on an equilateral triangle
inscribed in a square, oriented along the diagonal.

Robert





Date: Sat, 07 Jun 1997 15:37:24 -0300 (ADT)
From: John Smith <jon.pure@paston.co.uk>
Subject: Re: Bird base patterns.

At 04:38 AM 6/6/97 -0300, you wrote:

>I'll add to the mathematical perspective: if you simply specify "4 equal
>flaps of maximal length", you get a Waterbomb Base, which TreeMaker
>obligingly creates as the simplest solution. The Waterbomb Base is a 4-sided
>molecule; if you fracture this molecule into four 3-sided molecules (sorry
>for the jargon: "3-sided molecule" means a triangle whose crease pattern is a
>rabbit ear), then the unique solution is the Bird Base. From a TreeMaker
>point of view, the 5th point of a bird base is the price you pay to force the
>crease pattern to consist entirely of triangular molecules, a process I call
>"triangulation" of a crease pattern.

>
>
>
I am very interested in the contributions from Doug Philips and Robert Lang
with regard to bird base patterns. In my original comments I simply referred
to my work specifically on the bird base without elaboration. However my
original research, which it implied, on the techniques of Origami was
published in 1968. In this paper I put forward the idea that one of the
fundamental techniques of Origami is the creation of what I called 'surplus'
by a process of folding. This surplus material can then be used in the
creation of points or projections. I used the term 'freedom of movement' by
which I meant the positioning of a surplus, without involving or moving the
boundaries, created by originating folds.  I found a way of generalisation
this idea in the concept of a 'curve of freedom'. I defined this as, the
part of a circle traced by a point on the surplus of paper from an axis
constrained by folds. Using these principles I was able to generalise what I
believed were all of the curves of freedom for symmetrical folds from a
square of paper. This included, for example, the preliminary base.

When I first heard Robert Lane presenting his brilliant work on the
generation of bases, I remembered my original efforts. Roberts work is, of
course, of a high rigorous standard, whereas mine is usually empirical and
non-rigorous. I think, however, that my concept of 1968 of the set of curves
of freedom, is closely related to Robert Lang's general theorems but lacks
his deep insight and major contribution to Origami.

My main interest in such work was, and continues to be, the identification
of the constraints, and the study of what happens if these are broken.

Many thanks for the contributions to this fascinating discussion.

I am lookimg forward to hearing more,perhapsin New York

John.
John Smith
Norwich
England
e-mail  jon.pure@paston.co.uk





Date: Sat, 07 Jun 1997 15:59:12 -0300 (ADT)
From: JacAlArt@aol.com
Subject: Re: German Convention Book

What models are included in this book?





Date: Sat, 07 Jun 1997 16:02:37 -0300 (ADT)
From: JacAlArt@aol.com
Subject: Lang's new book?

What's included in the rumored new book by Lang (something about Flapping,
Inflating, Moving Origami)?





Date: Sat, 07 Jun 1997 17:09:21 -0300 (ADT)
From: havener3@delphi.com (geoline)
Subject: Some Promised Diagrams and New Website

Geez, y'all,

My new origami website is finally up at:
http://www.geocities.com/~jaspacecorp/origami.html

So sorry take me so long to finish the kimono paper doll diagrams and new
origami site.  Actually, I finished the diagrams a week and a half ago, but
was too ill to write the instructions.  Then when I finally feel well
enough to write the instructions, silly me, I haven't the foggiest dagdum
idea how to write origami instructions.  I don't know much about English
origami nomenclature.  Sorry.  I just fold them thar thangs.  So I just
went ahead and did the sort of how-to instructions a crafts/doll maker
would write.  Now I know why I just fold paper, lames' and silks.  Writing
origami how-tos without knowing origami nomenclature can be tedious.  Well,
if George Winston can compose pretty piano and guitar pieces without
knowing how to read music notation, then I suppose I can still fold paper
without knowing origami nomenclature.  My mind throws a blank whenever
someone talks about mountain folds, blintzes, half nelsons (opps, I don't
think that's an origami fold).  The kimono paperdoll instructions will be
online for as long as my craft and doll publishers let me keep the
copyright.

My origami is sort of a hybrid mixture of Chinese and Japanese folk art.
Chinese folk art tends to be more decorative and ornate and emphasizes
display as well as the object.

Um, since I just uploaded the html an gif files, there may still be some
mistakes in the links and graphics.  Sort of like, ya use one page as a
template for other pages and ya forget to change the file names.  Please
let me know if y'all come across any broken links, weird links, wrong
graphics.  My origami page is just real simple, basic html, no frills
layout.

And, yeah, I'll try Amy Huang's origami webring when I get a chance to
visit her site a little later.  My little guy belongs to a kid safe
webring.  The cool thang about special interest webrings is that I don't
have to update a long list of origami web links or politely ask each web
owner if I may add a link to their site.  'Tis the polite thing to do.

Mahalo nui loa from the land of the Delta Blues!

Geoline Havener-Li (twisted as always with or without the neuro damage)
havener3@delphi.com
http://www.geocities.com/~jaspacecorp/momsai.html     <bonsai>
http://www.geocities.com/~jaspacecorp/origami.html    <origami>





Date: Sat, 07 Jun 1997 17:57:27 -0300 (ADT)
From: skirsch@t-online.de (Sebastian Kirsch)
Subject: Re: German Convention Book

On Sat, 7 Jun 1997 JacAlArt@aol.com wrote:
> What models are included in this book?

Lots of fine models. Buy it, then you'll see. :>

OK, OK, here's the table of contents:

---
Gerbil, Witch and Water Jug by Lionel Albertino.
Shepherd's Dog by Edwin Corrie.
Several chairs and tables by Stefan Delecat.
Several models by Klaus-Dieter Ennen, including the Fox Mobile, Simba,
masks, elephants, penguins, butterfly, flies, and hearts.
Several models by Juan Lopez Figuera, including an elephant, a cat, a bird
and a hexagon (ditetrahedron).
The Cat and Reading The Paper by Herman van Goubergen.
Bernies Envelope by Doris Lauinger.
Several models by Jos Meeusen, including a twist modular and a landing
duck.
The "Parabolum" by Walter Praher.
And more, all in all 51 models.
---

Yours, Sebastian               sebastian_kirsch@kl.maus.de,skirsch@t-online.de

PS: How about including your name in your emails? I generally like to know
the name of the people I write to.





Date: Sun, 08 Jun 1997 00:13:15 -0300 (ADT)
From: "James M. Sakoda" <James_Sakoda@brown.edu>
Subject: Re: Treasure Boat

>Jim, I'm interested in getting a photocopy of the treasure boat you

>mentioned.  I wonder if it is similar to the modular units of the joss
paper

>flower I found in Malang, Indonesia.  Could you bring it to NYC?

>

>I've been folding joss paper to replicate the flower My cousin sent
from

>Hawaii.  Think I've finally got the proportions right.

>

>Thanks.

>Marcia Mau

>Vienna, VA USA

>marcia.mau@pressroom.com

Marcia, The treasure boat in Takagi's book,<bold> Koten ni miru
origami</bold> (Origami in Old Documents) is closely related to the
Chinese junk, and is probably not what you have in mind.  It is folded
from a single square piece of paper and is a boat with a squarish deck
at both ends and a space for cargo in the center.  In the illustration
one end is pointed and hence is not folded in the same way as the
Chinese junk that I learned from Murray and Rigney's <bold>Papaer
Folding for Beginners</bold>, reprint by Dover Publiations, 1960, New
York, NY.  The only folding instructions for it that I could find was
in Kosho Uchiyama's<bold> Origami Zukan. </bold>1959, Japan.  It isa
book for grade school children, but has a comprehensive collection of
traditional folds.

     The treasure boat is folded from a blinted double-boat whose sides
are folded back and then opened out to what is called a Omiya or
palace.  To make the treasure boat (Uchiyama calls it a <italic>
tennamasen </italic>, a kind of cargo boat) the side flaps of the
blintz fold are pulled out and in between remains the central part of
the Omiya.  One end is folded into a poind while the other is thinned
down to form  the blunt end of the boat.  The two ends are pulled apart
and like a miracle a square deck appears at both ends, with a hole in
the center for storage of goods.  The interesting part of the
construction is the fact in folding the Chinese junk one starts with a
box and fold the sides in half before pulling apart both ends to form
the decks at both ends, so that both boats are clearly similarly
constructed, but with clear difference at the pointed end.

     I can show you the treasure boat and also include   one with my
dollar bill folds.  By the way I am using Chinese joss paper which is
made to look like an Ameridan dollar bill.

     This experience in searching out instructions for the treasure
boat has got me wondering how many people really know how to fold the
old traditional folds such as the yakko-san or the komuso (or komoso)
or the double boat.  The komuso is folded from a modification of the
yakkosan.

     I look forward to seeing you at the convention.  James M. Sakoda,
origami dollar bill foldings in pdf form:  http://idt.net/~kittyv





Date: Sun, 08 Jun 1997 04:38:00 -0300 (ADT)
From: Rjlang@aol.com
Subject: Re: Origami data structure

Zachary wrote:

> One of the most difficult parts of writing an origami computer
> program is the problem of how to represent the paper so that
> it can be operated on and interpreted for diagrams.

Several years ago Jack Fastag and I wrote programs that simulated origami
folding -- i.e., you grab a corner (by clicking) and fold the paper (by
dragging) and the program computed the results and animated the in-between
folding. We started our projects independently, but when we compared notes
about how we were doing it, it turned out that we were using many of the same
ideas.

The first thing we did was, no surprise, use an object-oriented language so
that we could simulate low-level objects by encapsulating their state (as
member variables) and their behaviors (as member functions). We both used
Object Pascal, as it turned out (I also used the THINK Class Library, which
was a work of art before Symantec screwed it up); but if I were doing it
again, I'd use C++ and CodeWarrior PowerPlant (which, BTW, is what TreeMaker
is written in).

I modeled the paper as a collection of Polygon objects; each Polygon
contained a list of Edges, Vertices, and adjacent Polygons, as well as some
attributes like colorUp. Folding happened only along Edges. When you made a
new fold, the program would do the following:

1. Figure out the location of the fold line
2. Figure out which polygons were crossed by the fold line
3. Break each crossed polygon into subpolygons and create new edges, along
which the folding would take place
4. Figure out which polygons were moving (this was unexpectedly difficult
when multiple layers and trapped layers were included)
5. Animate the movement of the new polygons to their new positions and switch
the colorUp bit for the polygons that got turned over.

Zachary observed:

> The problem with [keeping track of layers by using the paper
> thickness] is that it doesn't answer the question of how to make
> use of those layers. In other words, the layers themselves are
> implicit in the structure, but very difficult to operate on.

The way I dealt with layers was that I maintained a "layer stack", a list
that had a strict ordering for the layer order of all Polygons. When you
folded a flap, the program not only calculated the new location of the
polygon, but also what the new layer order was. This wasn't as bad as it
might sound. This data structure was a simple ordered random-access
container, i.e., a List of pointers to Polygons.

This approach was a restrictive assumption, though, because strict ordering
doesn't allow you to simulate any structure in which layers go over-and-under
each other -- a woven Fuse box, for example. I devised an alternative
conceptually, in which the plane was broken up into polygons with a layer
stack being maintained for each polygon -- but that was getting pretty
complex and the payoff wasn't going to be worth the programming effort, so
that was about the time I called it quits.

Good luck with your project, Zachary. I'd be curious to see how it comes out.

Robert J. Lang
rjlang@aol.com





Date: Sun, 08 Jun 1997 09:01:08 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Re: Origami data structure

Robert said

> The first thing we did was, no surprise, use an object-oriented language so
> that we could simulate low-level objects by encapsulating their state (as
> member variables) and their behaviors (as member functions). We both used
> Object Pascal, as it turned out (I also used the THINK Class Library, which
> was a work of art before Symantec screwed it up); but if I were doing it
> again, I'd use C++ and CodeWarrior PowerPlant (which, BTW, is what TreeMaker
> is written in).

That sounds like good advice. I'll probably use GNU c++, even though I'm
really not proficient in it. Better to deal with my own abilities that
can be improved rather than the limitations of a language which can't.

> I modeled the paper as a collection of Polygon objects; each Polygon
> contained a list of Edges, Vertices, and adjacent Polygons, as well as some
> attributes like colorUp. Folding happened only along Edges.

That's basically what I have been working from, although your colorUp
attribute deserves a few words. It's a rather nice solution for dealing
with the problem of top and bottom. How does one keep track of which side
of the paper is which? If you try to derive it from the structure of the
model itself it can get very messy, following all those
computation-intensive twists and turns to arrive at the polygon in
question. If you try to just give a specific label to each side, how do
you identify each side in order to give it that label? Your colorUp
attribute takes advantage of the location of the observer, and the fact
that the model will tend to remain flat on the surface its folded on. So
if a polygon turns over *with regard to the observer*, you simply flip the
colorUp bit, which merely says whether that polygon will be colored in the
final picture. It's those kinds of things that seem obvious when you see
them, but which are very hard to come up with on your own, that are so
impressive.

> When you made a new fold, the program would do the following:
>
> 1. Figure out the location of the fold line
> 2. Figure out which polygons were crossed by the fold line
> 3. Break each crossed polygon into subpolygons and create new edges, along
> which the folding would take place

That is as far as I've gotten.

> 4. Figure out which polygons were moving (this was unexpectedly difficult
> when multiple layers and trapped layers were included)

I'd kind of like to see that alogrithm.

> 5. Animate the movement of the new polygons to their new positions and switch
> the colorUp bit for the polygons that got turned over.

I will thankfully not have to deal with animation for this project, since
all I want to do is create static diagrams.

> The way I dealt with layers was that I maintained a "layer stack", a list
> that had a strict ordering for the layer order of all Polygons. When you
> folded a flap, the program not only calculated the new location of the
> polygon, but also what the new layer order was. This wasn't as bad as it
> might sound. This data structure was a simple ordered random-access
> container, i.e., a List of pointers to Polygons.
>
> This approach was a restrictive assumption, though, because strict ordering
> doesn't allow you to simulate any structure in which layers go over-and-under
> each other -- a woven Fuse box, for example.

How did you deal with a polygon that had multiple polygons on top of it
but in different locations, so that they didn't interfere with each
other? So for instance, take a square of paper and lay it on the table.
Now take four other sheets and lay them so they are mainly off of the
first square, but one corner of each sticks over a unique edge of the
original square. So you have a sort of quincunx position, with none of
the outer squares above or below each other, but all of them on top of
the original sqaure.

> I devised an alternative
> conceptually, in which the plane was broken up into polygons with a layer
> stack being maintained for each polygon -- but that was getting pretty
> complex and the payoff wasn't going to be worth the programming effort, so
> that was about the time I called it quits.

I called it quits at that point myself. Isn't origami great!!! So it
seems like the final question is, what are the different ways that
layering can take place? If we can identify them all, we won't have to
worry about surprises coming to attack whatever data structure we come up
with.

1) straight layers with one on top of another (boring)
2) over/under layers in which layer 1 is above layer 2 which is above
layer 3 which is above layer 1 again.
3) independent polygons that are on top of another polygon, so that all
the independent polygons occupy the same layering position as each other.

Any others? Better yet, can anyone prove that there are *no* others?

Zack





Date: Sun, 08 Jun 1997 13:20:09 -0300 (ADT)
From: Erik Demaine <eddemain@daisy.uwaterloo.ca>
Subject: Re: Origami data structure

> One of the most difficult parts of writing an origami computer program is
> the problem of how to represent the paper so that it can be operated on
> and interpreted for diagrams.

Hi Zack,

I think this problem has been explored by origami mathematics.  Bern and Hayes,
for example, look at the overlapping order of flat origamis.  Although you
obviously don't want to go directly to a flat origami, a similar approach may
be viable.  (Rob Lang has already addressed this specifically.)

Essentially, you want to subdivide the faces of the crease pattern so that each
subface is identical to any other subface that it "shares space" with (e.g.,
touches).  In other words, you don't want to have big faces on top of little
faces, or faces partially covered by others.  To avoid this, you split them up
at the obvious locations.  You of course want to remember the original crease
pattern you started with.  In this sense, the data structure would represent a
multilevel mesh (albiet the number of levels is likely two, but you might want
to generalize past that).  This would solve the layering problem you've been
having.  This stuff isn't that hard; let me know if you want implementation
details (I've played with this during my work with finite-element simulations).
In general, I would call this approach (which is the one you've been
considering so far) a "topological" approach.

This is probably the approach I'd recommend for now.  Another approach is a
more implicit form of the origami.  You may be aware of the following
definition of an origami, similar to one that Tom Hull posted before on this
list.  An origami is a function f(p,t) where p is a point on the piece of paper
and t is a value between 0 and 1, inclusive, that returns a point in 3-space
which is where p is at time t.  To obey the rules of origami, it must satisfy
the following:

        - f is continuous.  That is, you don't rip the paper at all.

        - f is a piecewise-isometry on the faces of the crease pattern.  That
          is, each face is simply translated and/or rotated into 3-space; it's
          not stretched or shrunken at all.

          For some complex folds, you will need to relax this to allow curves.
          Unfortunately, this will make the functions much more complex.

        - Some kind of non-crossing condition.  Examples include:

            * for any t < 1, f is one-to-one.  That is, no two paper molecules
              occupy the same space until you are finished folding.  Since this
              model says that paper has zero thickness, this is insufficient
              for representing a fold-by-fold process.

            * If f(p,t) = f(q,t), then f(p,s) = f(q,s) for any s > t.  In
              words, once two paper molecules occupy the same space, they must
              for the rest of folding.  This is better than the previous
              condition, but it doesn't allow many non-trivial folds like
              a squash.

For an origami program, you are probably less interested in these properties,
but you want to ensure that what you produce are in fact origamis.  Hence,
if you wanted to prove your program "correct," so to speak, you'd need to show
that you can make a function satisfying these properties, that is, define the
"in betweening" of the folding.  So even though you don't want animation,
you will need to deal with it *if* you want to be rigorous (not necessary of
course!).

How would you use functions like this to represent origamis?  I think a nice
way to do it is to define "basis functions" (or building blocks if you like)
for the kinds of folds you want to represent.  You then "compose" a sequence of
these basis functions (that is, you do one, then another, and so on) to form
your overall origami.  Constructing basis functions for book folds, for
example, shouldn't be difficult, and eventually you can strive to add more and
more kinds of folds.  This provides a very modular (or object-oriented if you
like) way to define the origami program.

The advantages of this approach is that you can animate the folding process, it
corresponds more closely to a physical model of folding, and there is a way to
get rigorously sound origami almost for free.  (And as far as I know (alas!),
this is the only way to get rigorously sound origami.)  The disadvantage is
that constructing functions are hard.

Yikes, with all that description, it might sound like I actually know something
about this :).  And since this is my first posting to the list, I better
introduce myself.

I am a PhD student at University of Waterloo doing work with my dad, Martin
Demaine, and my advisor, Anna Lubiw, on origami mathematics.  We have
constructed functions for so-called extreme bases, which are a special case of
Rob Lang's uniaxial bases.  They're called "extreme" because they map the
boundary of the paper to a common plane, and map the rest of the paper above
that plane.  A simple example is the common "preliminary base," which is an
extreme base for a square piece of paper.  Extreme bases are a fundamental part
of a solution to the following folding-and-cutting problem: fold a piece of
paper as much as you like, make one complete straight cut, and unfold to see
what pieces you get; the goal is to cut out an arbitrary polygon.

We've gone through around four iterations now on these functions, and we
finally have them right (they're rigorously proved to be correct, so they
better be!  [alas, "proofs can only be shown the presense of errors, not their
absense" -Source forgotten]).  So here we have an infinite class of origamis
that we can formally show to fold.  Unfortunately, we're probably a long way
away (at least for now) from something more general that you would want for
your origami program.  I thought I'd mention it though, because we find it
very interesting.

> How does one keep track of which side of the paper is which?
normal vector (that is, one that points "straight up" from the plane containing
the face).  To determine if you're looking at the top of the face, just take
the dot product of the normal vector with the viewing vector, and see if the
value is positive (corresponding to the front side) or negative.  This is just
standard computer graphics; I can (fortunately) still remember it because I
took a course in CG recently :).  You can probably find more details in a book
like "Graphics Gems," whose examples are available online.

Of course, now your foldings have to compute the new positions of faces as well
as the new normal vectors.  This isn't hard; just apply your affine
transformation (e.g., translations and rotations) to your vectors as well as
your points.  Again, standard computer graphics; normals are typically used
(and hence computed over transformation) to compute smooth colors (so-called
Gourand shading) for rendering faces of polyhedra.

BTW, are you thinking of doing 3-D rendering?  If so, which renderer are
you thinking of using (or will you write your own)?

I'd be interested in corresponding further with you.
Erik
--
Erik Demaine                 ()  e-mail: eddemain@daisy.uwaterloo.ca
Dept. of Computer Science    ||  URL: http://daisy.uwaterloo.ca/~eddemain/
University of Waterloo       ||  PGP key: finger me.  "Maturity is switching
Waterloo, ON Canada N2L 3G1  ()  from passive voice to active voice" -P. Alder





Date: Sun, 08 Jun 1997 15:15:45 -0300 (ADT)
From: reeds@openix.com (Reeds family)
Subject: Re: Origami in the movies

>Hey,
>I hear that Nicholas Cage is an origami fanatic in the new movie "Con Air".
>Should be interesting...
>
>Mike
>
>____________________________________________________________
>Michael Bobrow
>You can find the University of Rochester Dermatology Web Page at...
>http://www.rochester.edu/MED/DERM

The latest New Yorker has a hilarious review of the movie, with several
refs to the origami motif.
Karen
reeds@openix.com





Date: Sun, 08 Jun 1997 21:29:11 -0300 (ADT)
From: "Shi-Yew Chen (a.k.a. Sy)" <sychen@erols.com>
Subject: Re: Origami data structure

Erik Demaine wrote:

> I am a PhD student at University of Waterloo doing work with my dad, Martin
> Demaine, and my advisor, Anna Lubiw, on origami mathematics.  We have
> constructed functions for so-called extreme bases, which are a special case of
> Rob Lang's uniaxial bases.  They're called "extreme" because they map the
> boundary of the paper to a common plane, and map the rest of the paper above
> that plane.  A simple example is the common "preliminary base," which is an
> extreme base for a square piece of paper.  Extreme bases are a fundamental
     part
> of a solution to the following folding-and-cutting problem: fold a piece of
> paper as much as you like, make one complete straight cut, and unfold to see
> what pieces you get; the goal is to cut out an arbitrary polygon.
>

Hi, Erik and anyone who is interested,

Do you have any related published paper/articles? Are they in Tom Hull's page
     link?
My interests is more related to model diagramming. Robert Lang's old works
     (folding
animation stuff) looks more like a perfect 2D pureland diagram tool to me
     (well...
with some improvement!) I believe the well done virtual paper folding animation
     would
beat all the current popular diagram editors.

I too have some interest in programming the folding animation. The truth is real
paper folding drags me away from this project all the time. The programming
     priority
is getting lower and lower... But I would love to know other's works in
     progress.

Now a different topic. For Lang's Treemaker He is using CodeWarrior.
     CodeWarrior has
multi-platform support? Are you going to have Treemaker for Windows 95 as well,
     dear
Dr. Lang? I can't afford Powermac now.

|------------------------------------------------------\
|  _     Shi-Yew Chen (a.k.a. Sy) <chens@asme.org>     |\
| |_| Folding http://www.erols.com/sychen1/pprfld.html --\





Date: Mon, 09 Jun 1997 08:33:22 -0300 (ADT)
From: hull@MATH.URI.EDU
Subject: Re: Origami data structure

Heeeeey!

Zack asked,

> How does one keep track of which side of the paper is which?

To be honest, I've only been reading this thread with one eye open,
probably due to my cold-wracked sinuses.  Thus perhaps my comment here
is useless, but if you're considering only *flat* origamis, then
there's a very easy way to keep track of which polygons of the
crease pattern are pointing "up" and which are pointing "down"
after the folding has been done.

It's pretty easy to show (or convince yourself) that every flat origami\
crease pattern is *two-face colorable*.  That is, if you color the regions
(faces) of a flat origami crease pattern with the restriction that no
two neighboring regions receive the same color (just as if you were
coloring a geography map), then you would only need two colors to do this.
Easy proof: fold the model and lay it on a table.  Each face is pointing
up or down.  Color all faces going up blue, and all down faces red.
If a face is pointing up (blue), then all its neighboring faces have
been foldes away, and thus must be pointing down, thus are red.  Bingo.

Now, there are many fast (i.e., polynomial time, possibly even linear)
algorithms for two-face coloring a graph.  So do this at the start of
your program.  The colors will give you a tag to determine if a
given face will be pointing up or down.

Hope that helps.

----- Tom "I'll go back to sleep now" Hull
      hull@math.uri.edu





Date: Mon, 09 Jun 1997 08:35:34 -0300 (ADT)
From: Kenny1414@aol.com
Subject: Re: Some Promised Diagrams and New Website

From: Kenneth M. Kawamura ( kenny1414@aol.com )

Aloha,

In a message dated 97-06-07 16:30:37 EDT, you write:

<< Please
 let me know if y'all come across any broken links, weird links, wrong
 graphics. >>

I got to your momsai page, tried to click on the origami link (the welsh
dragon), and hung my browser, and then my machine. Tried it three times to
make sure.

This may be a problem with the AOL browser, and not your page.

My machine is a '486 PC, running Windows 95, and I am using AOL (America
Online). I am using the AOL 3.0 for Windows browser, instead of the AOL 3.0
for Windows 95 browser, because the 95 browser won't work for me.

The message I got from Windows 95 said something about my program had
executed an illegal instruction, or something like that. I can't cut and
paste the message, and I'm too tired to hand copy it. The "Details" said
something like tried to execute a missing segment.

Mahalo,

Kenneth





Date: Mon, 09 Jun 1997 08:35:46 -0300 (ADT)
From: Kenny1414@aol.com
Subject: Re: Some Promised Diagrams and New Website

From: Kenneth M. Kawamura ( kenny1414@aol.com )

Aloha again,

May I please have permission to mail a printout of your origami dolls pages
to Rae Cooker in Midland, Michigan. She collects dolls, and isn't on the
Internet.

Mahalo,

Kenneth





Date: Mon, 09 Jun 1997 08:35:56 -0300 (ADT)
From: Charles Knuffke <knuffke@sirius.com>
Subject: Re: Origami in the movies

> Hey,
> I hear that Nicholas Cage is an origami fanatic in the new movie "Con Air".
> Should be interesting...
>

For those interested, the book that Nicholas Cage is given that leads to
the scene with the flapping bird model is "Complete Origami" by Eric
Kenneway. Unfortunately it's the only Origami reference in the movie.

*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Charles Knuffke       "Amen the Thunderbolt in the Dark Void"
San Francisco, CA                              -Jack Kerouac
mailto://knuffke@sirius.com

Check out the Pacific Coast Origami Conference Website at:
http://www.sirius.com/~knuffke/PCOC.html





Date: Mon, 09 Jun 1997 10:27:11 -0300 (ADT)
From: Aurora Lozada <alozada@notes.cc.bellcore.com>
Subject: -No Subject-

I was working on Fuse's modular book and could not figure out how to get the
pinwheel colors. I did the box with two colors following the instructions which
was simple.  However I could not figure out how the colors came out for the
pinwheel alternating black and white (p. 151 of Fuse's book).  Could anyone
help me with this?





Date: Mon, 09 Jun 1997 10:54:22 -0300 (ADT)
From: havener3@delphi.com (geoline)
Subject: Re: Some Promised Diagrams and New Website

geoline slipped:
>Um, since I just uploaded the html an gif files, there may still be some
>mistakes in the links and graphics.  Sort of like, ya use one page as a
>template for other pages and ya forget to change the file names.  Please
>let me know if y'all come across any broken links, weird links, wrong
>graphics.  My origami page is just real simple, basic html, no frills
>layout.

geoline, you really are  twisted!  You miscalculated some of the metric
conversion measurements!

Opps, sorry.  I try doing metric conversions 'cuz the net is an
international medium, but because most Americans think in old English
measures, I hosed some of the conversions.  Then again, my mind is on
vacation and my handy-dandy-tandy pocket international translator and
metric conversion calculator is buried under my messy desk.  I ought to put
up that java script metric conversion calculator online...or just be more
careful.  I'll go fix the few metric errors when I get through my email.
Otherwise, you non-Americans, please check the inches-to-centi and
milimeter conversions before measuring and cutting paper.

Speaking of Java....
For some of you who may be getting errors in Windows on a 486 machine or
other system configurations, I think it could be a java conflict from some
of the Geocities server ads.  My origami page uses basic HTML code and
Geocities sometimes throws-in some banners which run java code.  Also,
folks on older micro systems or machines with very limitted RAM tend to run
into fatal system errors when encountering some java ads.  I'm sorry for
the inconvenience this causes.  If you can find a way to turn-off java or
java script from your web browsers, maybe that may help.

Smiles....

Geoline Havener-Li (twisted as always with or without the dain bramage)
havener3@delphi.com
http://www.geocities.com/~jaspacecorp/momsai.html     <bonsai>
http://www.geocities.com/~jaspacecorp/origami.html    <origami>





Date: Mon, 09 Jun 1997 11:26:25 -0300 (ADT)
From: Lisa Hodsdon <Lisa_Hodsdon@hmco.com>
Subject: NO Java ads (Re: Some Promised Diagrams...)

geoline wrote:
>For some of you who may be getting errors in Windows on a 486 machine or
other system >configurations, I think it could be a java conflict from some
of the Geocities server ads.

I don't know whether this will help or not, but a co-worker found a
wonderful web aid
that you may want to check out. (I know it's available for the Mac; I don't
know how
cross-platform it is.)

WebFree eliminates most advertising from web pages. It searches for certain
tags (like
"ad") and prevents those items from loading. Since I started using it, I
haven't noticed
that anything I wanted was missing & I rarely have to sit around waiting
for those
annoying animations in the advertisements to do their thing. (It will also
turn off non-
advertising animations after the first cycle if you want! What joy!)

You can find it by visiting http://www.shareware.com and using "WebFree" as
a search term.

(I don't like NO as a tag for "non-origami" because I always read it as the
word "no."
All that discussion of "no laptops in NY" was confusing. Here, I like it.
It works both ways.

Lisa
Lisa_Hodsdon@hmco.com





Date: Mon, 09 Jun 1997 11:45:51 -0300 (ADT)
From: havener3@delphi.com (geoline)
Subject: Re: Origami data structure

Tom hulled:
>To be honest, I've only been reading this thread with one eye open,
>probably due to my cold-wracked sinuses.

Ah!  A fellow ill person!  Welcome to the club!

[snip]
>It's pretty easy to show (or convince yourself) that every flat origami\
>crease pattern is *two-face colorable*.  That is, if you color the regions
>(faces) of a flat origami crease pattern with the restriction that no
>two neighboring regions receive the same color (just as if you were
>coloring a geography map), then you would only need two colors to do this.
>Easy proof: fold the model and lay it on a table.  Each face is pointing
>up or down.  Color all faces going up blue, and all down faces red.
>If a face is pointing up (blue), then all its neighboring faces have
>been foldes away, and thus must be pointing down, thus are red.  Bingo.

Another way to visually resolve multi-layers of face and back folds is use
two basic colors like red and blue and add color gradients of the two
colors to represent each layer level.

>Now, there are many fast (i.e., polynomial time, possibly even linear)
>algorithms for two-face coloring a graph.  So do this at the start of
>your program.  The colors will give you a tag to determine if a
>given face will be pointing up or down.

I have been too ill to really get into the discussion Zachary, Robert,
Erik, et al, where having about programming a multi-layer origami CAD
system.

A Programming Language (APL) which would be very well suited to do
multi-layered origami algorithms is an old mathematical programming
language called APL.  Not too many people know about APL.  It is that weird
programming language which uses Greek characters and reads right to left in
reverese Polish notation.  This mathematical language has very powerful
multi-dimensional array and matrix functions suited for origami topology.
APL just needs a graphical upgrade to turn origami topology into a powerful
tool.  I do not program any more, but I know of a Silicon Valley software
engineer who did his masters thesis on APL.  While he probably has not
touched APL in 20+ years or so, he enjoys collecting my origami pieces.
Maybe I can drag him into the discussion.  Upgrading a powerful
multi-dimensional matrix manipulation language like APL would make a great
mathematical or programming thesis for some math wizard.

Geoline Havener-Li (brained as always with or without the twist damage)
havener3@delphi.com
http://www.geocities.com/~jaspacecorp/momsai.html     <bonsai>
http://www.geocities.com/~jaspacecorp/origami.html    <origami>





Date: Mon, 09 Jun 1997 11:58:53 -0300 (ADT)
From: rhudson@netrax.net (Hudson-Robert)
Subject: Origami DB structure

Speaking of Origami and computers,

I've been working out a tentative Entity Relationship Diagram (aborted from
a college DB project that I worked on eons ago) to describe origami models,
diagram locations and preferred paper sizes.  Anyone else into DB design
and willing to take a look at/discuss a relational model?  The central
entity is the conceptual "model", not a particular model.  For example, I'm
not cataloguing every Max Hulme squirrel I've ever made (e.g. paper type,
etc), I'm cataloguing the Max Hulme squirrel "design"

Rob





Date: Mon, 09 Jun 1997 12:02:40 -0300 (ADT)
From: rhudson@netrax.net (Hudson-Robert)
Subject: Oru for sale

Hi Everybody--

I'm selling my copy of the latest Oru (Spring 1997), the Flowers issues,
for $25+shipping.  Anyone interested, please e-mail me.

Rob





Date: Mon, 09 Jun 1997 12:31:34 -0300 (ADT)
From: Bruce Stephens <B.Stephens@isode.com>
Subject: Re: Origami data structure

havener3@delphi.com said:
> A Programming Language (APL) which would be very well suited to do
> multi-layered origami algorithms is an old mathematical programming
> language called APL.  Not too many people know about APL.  It is that
> weird programming language which uses Greek characters and reads right
> to left in ...

I think it's unwise to discuss trivial details like which programming language
is appropriate (but I will, anyway).  I'd go along with Robert Lang's
suggestion that an object oriented language is probably a good idea.  Beyond
that, I suspect Zachary is best off choosing something that he can get to
grips with easily, and which seems to provide whatever features he wants.
Assuming he wants other people to be able to play with it, or contribute, then
choosing something that's freely available and pretty commonly used is
probably good.  (Commonly used so there's a good chance we'll be able to
understand it, so that probably rules out APL, even if there's a free
implementation around somewhere.)

C++ (whether GNU or otherwise), Perl5, Tcl, Scheme, would all seem reasonable
choices, whether alone or in combination (perhaps with other tools like yacc
if that's appropriate).





Date: Mon, 09 Jun 1997 13:01:55 -0300 (ADT)
From: Howard Portugal <howardp@fast.net>
Subject: Re: Origami DB structure

>Hudson-Robert wrote:
> Anyone else into DB design
> and willing to take a look at/discuss a relational model?

Hi Rob,

I'd be willing to take a look at the design and discuss things.

Howard
--
Howard Portugal   |  When you have eliminated the impossible,
West Chester, PA  |  whatever remains, however improbable,
howardp@fast.net  |  must be the truth.
                 |  Sir Arthur Conan Doyle
                 |  Sherlock Holmes, in The Sign of Four, ch. 6 (1889).





Date: Mon, 09 Jun 1997 14:40:14 -0300 (ADT)
From: Robby/Laura/Lisa <morassi@zen.it>
Subject: Re: NO Java ads (Re: Some Promised Diagrams...)

Lisa,
At 11.26 9/6/1997 -0300, you wrote:

>(I don't like NO as a tag for "non-origami" because I always read it as the
>word "no."

Suggestion: OT for "off-topic" is a common tag. Why don't we use it instead ?

Roberto





Date: Mon, 09 Jun 1997 16:05:42 -0300 (ADT)
From: Erik Demaine <eddemain@daisy.uwaterloo.ca>
Subject: Re: Origami data structure

Shi-Yew Chen (a.k.a. Sy) wrote:
> Do you have any related published paper/articles? Are they in Tom Hull's page
> link?

The paper hasn't been finalized yet.  I'll let the list know as soon as it is.
It should be sometime this month (before the OUSA convention).

Cheers!
Erik
--
Erik Demaine                 ()  e-mail: eddemain@daisy.uwaterloo.ca
Dept. of Computer Science    ||  URL: http://daisy.uwaterloo.ca/~eddemain/
University of Waterloo       ||  PGP key: finger me.  "Maturity is switching
Waterloo, ON Canada N2L 3G1  ()  from passive voice to active voice" -P. Alder





Date: Mon, 09 Jun 1997 16:47:29 -0300 (ADT)
From: havener3@delphi.com (geoline)
Subject: Re: Origami data structure

Bruce Stephens <B.Stephens@isode.com>
>I think it's unwise to discuss trivial details like which programming language
>is appropriate (but I will, anyway).

I beg to differ that programming language for creating a dynamic origami
CAD program is trivial or unwise.

One of the problems I see Robert Lang and Zachary Brown encountering in
designing multi-layered origami models is rendering multi-matrix, origami,
double topology mathematics visually.  In order to manipulate matrix
mathematics to visually represent origami topologies, a powerful
mathematics and topology tool is needed.  APL is the most powerful matrix
mathematics manipulation tool I can think of for planning a good origami
CAD.  If you can manipulate multi-dimensional APL matrices, then you can
construct a CAD program to manipulate origami structures.

My suggestion to study and implement APL matrix mathematics makes good
sense in overcoming some the difficulties in tracking, tracing and
rendering origami topologies on a two dimensional screen.  Granted, I am
getting into a very esoteric area of programming and mathematics, but if
someone wants to design an origami CAD, he should understand the
limitations and strengths of certain programming tools.  Any designer must
understand his tools and resources.

If one of the more contemporary computer languages could access APL
multi-dimensional matrix-type functions, then designing an origami CAD
would be a whole lot easier to do.  Most of us will not need to see the
programming involved in designing an origami CAD.  What we will see is a
more powerful computer-aided origami design tool.  Such a design tool could
also be used in architecture, engineering, physics and molecular biology as
well as pretty paper folding.  Thus, even my suggestion is esoteric to many
people, the few people who may understand the computational esoterica can
perhaps take my suggestions to heart and design a better origami mouse
trap.

Oooo, I must be feeling better.  I am discussing esoterica again.  Bonsai
newsgroup/list beware!

Geoline Havener-Li (mommy extraodinaire)
havener3@delphi.com
http://www.geocities.com/~jaspacecorp/momsai.html     <bonsai>
http://www.geocities.com/~jaspacecorp/origami.html    <origami>





Date: Mon, 09 Jun 1997 17:28:08 -0300 (ADT)
From: "Goveia, William P" <wgoveia@indiana.edu>
Subject: RE: Origami data structure

I think Bruce's comment was meant to be a comment on the proper steps in
the Applications/systems design process (I may be wrong).  If that is
what he is speaking about, then he is right on the money.

Typically, when one is looking at designing Applications or Systems, one
generally puts the selection of a programming environment dead last.
The reason for this is that the selection of the programming language
must be based on many different aspects of the project, not the least of
which is the stated purpose, and when that is determined, there are data
types, database design (should the application use a database), the
states of being for the entities the application is being developed for,
etc.  The staed purpose can sometimes be more dfficult than it sounds.

Of course, durig this process, it usually becomes more and more apparent
that one particular environment will be better suited that another
fairly early in the process.  Far from trivial, it is last becuase of
it's importance...

I am sorry I was out of town last week and didn't contribute, but the
points I would have added to the discussion have already been discussed
more eloquently, I am sure, than I would have done.  Hat's off to Zack
and Co. for tackling this.  If you were to hark back to my introcution
on the list some months back, I had asked if there were interest in such
a project, or if anyone was working on it.  Much to my (pleasant)
surprise, apparently there is!

William Goveia, LAN Operations and Applications Specialist
Education Technology Services
School of Education, Indiana University at Bloomington
http://education.indiana.edu/~wgoveia

> -----Original Message-----
> From: havener3@delphi.com [SMTP:havener3@delphi.com]
> Sent: Monday, June 09, 1997 2:48 PM
> To:   Multiple recipients of list
> Subject:      Re: Origami data structure
>
> Bruce Stephens <B.Stephens@isode.com>
> >I think it's unwise to discuss trivial details like which programming
> language
> >is appropriate (but I will, anyway).
>
> I beg to differ that programming language for creating a dynamic
> origami
> CAD program is trivial or unwise.
>
> One of the problems I see Robert Lang and Zachary Brown encountering
> in
> designing multi-layered origami models is rendering multi-matrix,
> origami,
> double topology mathematics visually.  In order to manipulate matrix
> mathematics to visually represent origami topologies, a powerful
> mathematics and topology tool is needed.  APL is the most powerful
> matrix
> mathematics manipulation tool I can think of for planning a good
> origami
> CAD.  If you can manipulate multi-dimensional APL matrices, then you
> can
> construct a CAD program to manipulate origami structures.





Date: Mon, 09 Jun 1997 19:17:25 -0300 (ADT)
From: Kenny1414@aol.com
Subject: Re: NO

>I don't like NO as a tag for "non-origami" because I always read it as the
> word "no."

It's even more confusing if you happen to know a little Hawaiian.
The Hawaiian word for "Yes" is "No".

[By the way, I apologize to everyone for occasionally replying to the list
when I meant to reply to the person. I am a klutz, and haven't got into
the habit of using "send later" and double-checking the "send-to".

I don't usually post separate apologies, since I'm pretty sure you-all can
tell  when I've done it again, from the content, and know it's
unintentional, and I don't want to make matters worse by sending
a second unnecessary message to the list.

This one, however, is meant for the list.]

Aloha,

Kenneth Kawamura
kenny1414@aol.com





Date: Mon, 09 Jun 1997 21:39:46 -0300 (ADT)
From: Mike and Janet Hamilton <mikeinnj@concentric.net>
Subject: Re: -No Subject-

Aurora Lozada wrote:
> I was working on Fuse's modular book and could not figure out how to get the
> pinwheel colors. I did the box with two colors following the instructions
     which
> was simple.  However I could not figure out how the colors came out for the
> pinwheel alternating black and white (p. 151 of Fuse's book).  Could anyone
> help me with this?

Which of Fuse's books were you working from?  You can give us the ISBN
if the title is Japanese.

--
mailto:Mikeinnj@concentric.net
http://www.concentric.net/~Mikeinnj/





Date: Tue, 10 Jun 1997 01:32:08 -0300 (ADT)
From: carpentr@rmi.net
Subject: Re: Origami DB structure

Rob

I've done a fair amount of relational design work (primarily DB2) and
would be happy to go over your thoughts with you. Email me what
you've got so far & I'll try to add value to your ideas.

Andy Carpenter
carpentr@rmi.net

Date:          Mon, 9 Jun 1997 11:59:03 -0300 (ADT)
From:          rhudson@netrax.net (Hudson-Robert)
Subject:       Origami DB structure

Speaking of Origami and computers,

I've been working out a tentative Entity Relationship Diagram (aborted from
a college DB project that I worked on eons ago) to describe origami models,
diagram locations and preferred paper sizes.  Anyone else into DB design
and willing to take a look at/discuss a relational model?  The central
entity is the conceptual "model", not a particular model.  For example, I'm
not cataloguing every Max Hulme squirrel I've ever made (e.g. paper type,
etc), I'm cataloguing the Max Hulme squirrel "design"

Rob





Date: Tue, 10 Jun 1997 06:19:50 -0300 (ADT)
From: Bruce Stephens <B.Stephens@isode.com>
Subject: Re: Origami data structure

havener3@delphi.com said:
> My suggestion to study and implement APL matrix mathematics makes good
> sense in overcoming some the difficulties in tracking, tracing and
> rendering origami topologies on a two dimensional screen.  Granted, I
> am

Yes, maybe I'm wrong.  I think it would be really interesting to look at what
matrix operations would be convenient for origami.  It might well turn out
that the richness of APL is the Right Language, and that providing suitable
features in another language just wouldn't work satisfactorily.  Not having
tried it myself, I can't really claim any insight.





Date: Tue, 10 Jun 1997 10:14:26 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Re: Origami data structure

Erik said
> Essentially, you want to subdivide the faces of the crease pattern so that
     each
> subface is identical to any other subface that it "shares space" with (e.g.,
> touches).  In other words, you don't want to have big faces on top of little
> faces, or faces partially covered by others.  To avoid this, you split them up
> at the obvious locations.  You of course want to remember the original crease
> pattern you started with.  In this sense, the data structure would represent a
> multilevel mesh (albiet the number of levels is likely two, but you might want
> to generalize past that).  This would solve the layering problem you've been
> having.  This stuff isn't that hard; let me know if you want implementation
> details (I've played with this during my work with finite-element
     simulations).
> In general, I would call this approach (which is the one you've been
> considering so far) a "topological" approach.

This looks like a good solution, and it irks me because it's similar to a
solution I came up with long ago and abandoned because I did not
associate the non-crease polygons with polygons. Instead I saw them as
just arbitrary lines that would have to be stored in very ugly ways. If,
as you say, everything is considered a polygon, while some lines have an
extra attribute that indicates that they are creases, suddenly the data
structure looks a lot more managable.

Robert, did you consider and reject this idea? Does anyone see a reason
why it might not be good?

Zack





Date: Tue, 10 Jun 1997 10:15:33 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Re: Origami data structure

Shi-Yew Chen said
> I too have some interest in programming the folding animation. The truth
> is real paper folding drags me away from this project all the time. The
> programming priority is getting lower and lower... But I would love to
> know other's works in progress.

I am getting the feeling that a lot of programmers either have or are
working on various origami projects. Maybe if we all pool our efforts we
could come up with something good.

Zack





Date: Tue, 10 Jun 1997 10:15:45 -0300 (ADT)
From: Zachary Brown <zbrown@lynx.dac.neu.edu>
Subject: Re: Origami data structure

Geoline said
> A Programming Language (APL) which would be very well suited to do
> multi-layered origami algorithms is an old mathematical programming
> language called APL.  Not too many people know about APL.  It is that weird
> programming language which uses Greek characters and reads right to left in
> reverese Polish notation.  This mathematical language has very powerful
> multi-dimensional array and matrix functions suited for origami topology.

I have searched for APL on altavista with no luck. I am personally not
sure it is the right tool, because the compiler will need to do more than
just those mathematical operations and because it will be hard for future
programmers to maintain (since they probably won't know the language), but
I'm open to the possibility. Where can I find a description of it,
preferably on the net?

Zack
