Random ramblings:
=================

* Remove all printf (debug.C, Solver.C, Stats.C, Stats.h  and Parser.h)
   Move to stream(lined) output!

* Improve sats handling.
   The statistics handling are now spread all around the code. Should
   be turned off for speed by some compiling option maybe.
   
* Better options.
   The one we have now are confusing. We need a better way of
   controling the output. (Maybe on/off-switches for the different
   "c", "s" and "v" fields we have)
   
* Remove variable ordering from class Solve
   At least move all the variables and stuff into a struct so the
   Solve class *looks* smaller and less confusing. (Removed all DB
   stuff, code must be cleaned.)
   
* Make the Solve class smaller in general
   This class is simply to big. To much is done in one place. Should
   be splitted up in smaller units.

* Constraints as dynamic modules (low priority)
   It would be cool to be able to load constraints dynamically by some
   --load-constraints option. Should really not decrease efficiency
   since we already use pointers and such. A little more hassle when
   destroying objects, but all that happends in only a few
   places. Should be able to control that.

* Convert to autotools (high priority)
   Should not be hard if there are som scripts for checking for
   boost::program_option and tcl. (partly done, "removed" tcl)

* Reorganize Main.C
   It's to big. Should be splitted in three parts. One to handle
   commandline arguments, one to do the general solving loop and a
   final one to print statistics. main should look something like this
   pseudocode:

   <do comandline parsing>
   <read constrains>
   <solve problem>
   <print statistics etc.>

   (partly done)

* Revrite the parser.
   It's buggy. It's big. If you for instance sends a file with an
   incorrect <type> the whole ting crash and burns... It's very bad
   indeed!

* Rewrite the jmf constrain
   At least rename it to something other than only swedes can
   understand like compare (since I myself get irritated when som
   interesting piece of code is written with variable names and
   comments in some language I don't read)(Its now called Lex). It is
   also something of a hack. Should be cleand up. A nicer algorithm
   would not hurt either.

* Check spelling
   Have to fix spelling errors all over tha place.

* Check files
   The included non-source files are mostly wrong (especially COPYING
   and README). Must fix an INSTALL file also.

* Constraints
   Write an mod constraint (i.e. true if x1 + x2 + ... + xn = k mod
   n).

* Constraints
   Write a special clause for 2 and 3 clauses.

* Constraints
   Integer weighted linear constraints.

* Constraints
   Chu Min Li constraints (x1 + x2 + x3 => y (mod 2)).

* Sorting
   Sort watches at restarts so "short" constraints comes first.

* Method (r2)
   Add a k-Stålmarck method. Make a lot of conclusions from the truth
   tables (i.e. xor-clauses, conflict clauses, implications, unit
   clauses, Chu Min Li clauses, AtMost clauses)

* Linear solver (mod 2) (r3)
   Using Gauss-Jordan elemination on the xor clauses to simplify the
   xor clause database.

* Implication graph (r4)
   Build an implication graph and find strongly connected
   components. Use (a^b^c) and the implications a->d, b->d and c->d to
   make the conclusion d.

* Subsumtion (r1)
   Implement a fast subsumption algorithm. Its nessecery if we want to
   implement other stuff.

* Simplifications
   Look at Ostrowskis paper and implement some simplification rules...

* New variables
   Make a machanism to add new variables of type x = y op z.

* a -> b => -b -> -a
   When doing ULP(a) we can get an implication a->b. This implies that
   ehwn we do UPL(-b) we should get -a. Make this happen!

* Write constraints
   Write methods to print constraints to file.

* Splitranking
   Write some sort of variable ranking to file.

* SimplifyDB
   Write simplifying rules for Lex, AtMost and CNF that shortens the
   sonstraints.

* Adding "ordered solutions"
   Order the solutions by "inclusion" (i.e. true > false and a x
   solution is a subsolution of a solution y if xi <= yi) and (when
   looking for all solutions) only allow new non-subsolutions.

Well, better get writing some of this stuff than write about them.
