Faster optimal solver.

This is a pretty big one, but unfortunately performance only improved by about 5%.
I implemented one of the main ideas of nxopt, that is switching to the
inverse scramble on the fly if it gives a lower branching factor.
On the one hand it makes sense that it does not have such a huge impact, since
it only rarely happens that we do have a lower branching factor on inverse, but
on the other hand I am quite sad that the improvement is barely noticeable :-(
Maybe the problem is that I have introduced a lot of new overhead and I can improve
that in the future. Or maybe I am just overlooking something stupid.

1 files changed, 5 insertions, 3 deletions

diff --git a/src/steps.h b/src/steps.h
index e145c64..a55a101 100644
--- a/src/steps.h
+++ b/src/steps.h
@@ -7,8 +7,10 @@
 
 extern Step *           steps[NSTEPS];
 
-void                    free_localinfo(LocalInfo *li);
-LocalInfo *             new_localinfo();
-void                    prepare_step(Step *step, int nthreads);
+void                    copy_estimatedata(EstimateData *s, EstimateData *d);
+void                    free_estimatedata(EstimateData *ed);
+void                    invert_estimatedata(EstimateData *ed);
+EstimateData *          new_estimatedata();
+void                    prepare_step(Step *step, SolveOptions *opts);
 
 #endif