
Try:

To build the optimizer, type
*)    make optimqr

Depending on what system you're running on, you may
or may not need to change compilation definitions in
the Makefile.

If you do not want to use the bipartite-matching row
ordering strategy, you will also have to change the
makefile before compiling.  You should consult the
documentation about this issue.

To optimize a sample 20x20 system, type
*)    ./optimqr system.20x20

The output from the optimizer should looke like:
#######################################################
# Using 0.680000 as acceptance factor
# Using Output as output directory
# Loading matrix structure... 20x20 system loaded.
# System density is 20.500 %
# Initializing memory subsystem...
# dmh allocated 800000 solution buffers
# dmh allocated 2112711 small buffers
# Initial solution has f() = 3200
# Starting branch-and-bound search...
# 18:49:56 (BB) live nodes: 0, (min,mean)g()+h():  (0,0)
# (Delete)(Sort)(ln:82)
# BB: Better solution found! f(s) = 321
# (Delete)(Sort)(ln:637)
# BB: Cleaned away 121 obsolete live nodes
# BB: Better solution found! f(s) = 311
# (Delete)(Sort)(ln:1000)
# BB: Cleaned away 56 obsolete live nodes
# BB: Better solution found! f(s) = 306
# (Delete)(Sort)(ln:961)
# BB: Cleaned away 32 obsolete live nodes
# BB: Better solution found! f(s) = 300
# (Delete)(Sort)(ln:130)
# BB: Cleaned away 27 obsolete live nodes
# BB: max. no. of live nodes was: 1057
# BB: stopped after 87 iterations.
# Optimal solution has f(best) = 300
# Heuristic:
#  2382 calls
#  abort value is 3200
# DMH statistics:
#  Free buffers:   799994
#  Taken buffers:  6
#  Allocs done:    2389
#  Frees done:     2383
#  Free sbuffers:  2112711
#  Taken sbuffers: 0
#  sAllocs done:   142696
#  sFrees done:    142696
#######################################################

Now, we copy the sequence information from the
output directory to the current directory
*)    cp Output/optimqr.seq .

And, we generate a solver (in the file fastqr.f), 
specifying explicitly, that we want all factorization
loops to be unrolled (this is often the most efficient
option)
*)    ./codegen.pl -uf

The output from the code generator should look like:
#######################################################
# ---------------------------------------
#     Unroll all factorization loops: yes
#  Allow extra work (loop minimizer): no
#  Unroll all backsubstitution loops: no
#          Generate debugging checks: no
# ---------------------------------------
# System dimension is 20
# System holds 82 non-zeros
# Row-/column ordering read
# Building info file for the regression tester
# Building ordered-system file
# Generating code pre-amble
# Generating code for QR factorization...
# Building final-system file
# Generating code for back substitution...
# Terminating Fortran routine
# -------------------------------
# Total FLOP count:    2801
# In factorization:
#  Looped eliminations: 0 (0)
#  Single eliminations: 417
# In backsubstitution:
#  Looped eliminations: 55 (11)
#  Single eliminations: 69
# -------------------------------
# Done.
#######################################################

Then, we build the regression/benchmarking testing utility
*)    make regress

And finally, we run it to see if it works
*)    ./regress

The output from the regression tester should look like:

#######################################################
#  System has dimension 20
#  Regression testing...
#  Regression test passed.
#  Maximum error was   1.79945102E-16
#  Mean error was      8.40993941E-20
#  Benchmarking...
#  Done
#######################################################

