ddc-core-flow: rate inference: found an error in the paper! the 'sole parents' lemma is actually incorrect if one node is the child of another. so 'parents(a,b)' may have multiple possibilities if 'a' is parent of 'b'. in this case, we need to use the most specific parents, which would be '(a,a)'.
ddc-core-flow: 1. simplify integer program before passing to cbc. 2. fusion preventing path must check for paths in either direction. 3. when adding filter constraints, check if there is a fusion preventing path between any of the parents; if there is, they cannot be fused.
Tetra and Salt: add the top-level region rT.

Because Flow has no region information, we need a top-level mutable
region that we can place the allocated objects in.
Make iteration size of nodes in graph optional.

Not all nodes in the graph represent loops in the output program -
externals and input nodes, for example. As a result, these nodes cannot
be fused with anything at all. So we set their iteration size to
Nothing, and only nodes with sizes can be fused together.
ddc-core-flow: rate: only add weight constraints when no edges.

It is not necessary to add the weight constraint
> -N(F u v) <= O v - O u <= N(F v u)
when there is an edge between u and v, as a more restrictive constraint
>  1(F u v) <= O v - O u <= N(F v u)
will be added as well.
In this case, we also needn't add the filter constraints: if a and b
have a fusible edge between them and have different but fusible types,
then the parent transducers of a and b must be (a,a) or (b,b).
add totalwar output to gitignore
ddc-core-flow: to-tetra: add run and box casts when converting flow to tetra
ddc-core-flow: to-tetra: update test output
ddc-core-flow: add vwrite# and vnew# to flow->tetra conversion
core-tetra: work on Curry transform
tetra: give readPtr# and writePtr# another type arg for the type of the offset value
ddc-core-flow: convert: add Nat# arg to readPtr#
It's a bit much to require anybody who uses ddc to have an ILP solver.
(At least, until we have a pure Haskell ILP solver)
So I have implemented a simple, greedy clustering algorithm that will suffice most
of the time. It's based on the idea Clemens Grelck told me at FHPC:
first, greedily fuse vertically, then perform any horizontal fusion.
This actually works very well.

To enable ILP-based clustering, simply add
> DDC_FLOW_USE_LINEAR_SOLVER = 1
to your make/config-override.mk. Make sure you have limp-cbc installed.
If switching between the two, you may find you need to touch these
files:
    packages/ddc-core-flow/DDC/Core/Flow/Transform/Rates/Clusters/Linear.hs
    packages/ddc-core-flow/DDC/Core/Flow/Transform/Rates/Clusters.hs