Context:  This program makes a list of about 400 tetrahedra
and then performs various geometrical tests on them.  For
instance, it shows that pairs of unequal tetrahedra
are either disjoint or only intersect along a common
face, edge, or vertex.

The word tetrahedron is a bit specialized.  For me,
a tetrahedron is a list of 4 "interval complex vectors".
Each interval complex vector is a list of 3 "interval complex numbers".
An "interval complex number" is a list of two "intervals".
An interval is a pair of doubles.
So, a single tetrahedron has a lot of info in it.
I store the tetrahedra in a class that I call poly.
(The poly can have up to 10 vectors.)

The main part of the program creates two lists of
polys.  Rather than use arrays, I store these in
two data structures called poly_list.   The file
struct.c has all the different data structures.


Possible problem:  I think that all the problem is
with the structure poly_list.  This thing is supposed
to contain 225 polys.  When I lower this number to
about 35, the program partially runs.  I think that
somehow the high number (225) is overloading the
computer.  I don't know how to fix it myself.


Here is some documentation for this directory and
the files that it contains.
This directory contains the computational kernal of our
programs.  Here is a list of the files in the directory.


 list.c
 struct.c
 interval.c
 algebra.c
 output.c
 numerical_values.c
 polyhedron_operations.c
 pieces_of_Z.c
 pieces_of_Z_prime.c
 edge_intersection.c
 projection.c
 edge_smash.c
 triple_smash.c
 degenerate_smash.c
 cutoff_test.c
 injectivity_test.c
 subdivision_test.c
 matching_test.c


These files have their own documentation.  Here is an
overview.

list.c:  contains the above list, with #include statements.
This file is invoked by files in other directors which run
the computational kernal.

struct.c:  this file contains the basic data structures.

interval.c: our interval arithmetic file

algebra.c:  this file contains the basic algebraic routines
which manipulate our data structures.  Mainly, we define
complex arithmetic and some vector arithmetic.

output.c:  This file is not actually used when the programs
run. However, it contains some simply programs for printing
out various of the data structures.  We used this file
extensively when we were debugging the code.

numerical_values.c:  Contains the main numerical values in
the paper.

polyhedron_operations: contains the routines which
perform the basic operations on polyhedra:  
-finding the center of mass
-subdividing
-counting the number of vertices in common
-acting on a polyhedron by a group element

pieces_of_Z.c:  this file contains the definition
of the tetrahedra which comprise the complex Z.

pieces_of_Z_prime.c:  this file contains the definition
of the tetrahedra which comprise the complex Z'.

edge_intersection.c:  This file contains our computational
tests which compute the number of intersections between
circular arcs.  Our graphical user interface allows you
to test that these routines work as they should.

projection.c:  This file contains the Projection Test
and the Multiple Projection Test, as described in 
Ch 9 of the paper.

edge_smash.c:  This file contains the routines which
perform the Edge Smash Test, as described in Ch 9 of
the paper, for pairs (T,T') such that
(T#T')=2.

triple_smash.c:  This file contains the routines which
perform the Edge Smash test to pairs (T,T') such that
(T#T')=3.

degenerate_smash.c:  This file contains degenerate
versions of the Edge Smash Test 
It is invoked for 33=3+30 pairs of
tetrahedra, out of thousands.

cutoff_test.c:  This file contains the routines which
perform the crude estimate in Ch 9, showing that pairs
of tetrahedra outside the computational range are
disjoint from each other.

injectivity_test.c:  This file contains, in a summary
fashion, the main tests we perform on pairs of tetrahedra.
We simply list out every relevant pair and then farm
out this pair to the appropriate test, contained in one
of the above files.

subdivision_test.c:  This file contains the tests in
Ch 9.1, which rely on the subdivision of edges,
triangles, and tetrahedra.  These tests are the
Purity Test and the Affine Test.  This file also
checks the computation done at the end of Ch. 8

matching test.c:  This file contains the test which
shows that the numerical way of computing matches is
the same as the combinatorial way.  Our code uses
the combinatorial way exclusively, and we just want
to see that we're not making a mistake.  Also, the
matching test shows that combinatorially distinct
vertices, within the computational range, are
really distinct numerically.
