Forrest-Tomlin (#29)

* test

* when performing a forward transformation as part of a simplex step,
store "w" for later use when the basis is being updated

* find the index of a row in the permutation matrix

* more work on pushEtaMatrix(): update the _A matrices according to the
new eta matrix.

* refactoring: we know that always R=invQ, so just compute it once (when
Q) is changed and use it afterwards. Eliminated the R terminology.

* use Q, not R

* update the factorization when an eta matrix is pushed

* small bug fix

* done working on pushEtaMatrix, test now passes.

* store and restore operations for the new FT basis

* added functionality for computing the explicit basis from an FT factorization

* keep track of the availability of the explicit basis

* dumping functionality

* unit test + bug fix for explicit basis computation

* initial work on basis inversion using FT factorization

* bug fix

* todo

* removed a too-strong assertion

* use FT by default.
Bug fix.
All unit tests now pass

* get rid of the concept of "storedW"
add Duligur's fix for cost function resizing

* bug fixes and optimizations in BTRAN and FTRAN

* optimizations

* bug fix

* comment

* minor

* Switching to a non-fixed number of AlmostIdentityMatrices

* bug fix in LU factorization

* a test for comparing the two factorizations

* git ignore

* refactorize when the number of A matrices exceeds a threshold

* undo a couple of changes before merge

* fix broken test

* allocate work memory once-and-for-all

src/basis_factorization/.gitignore

@@ -0,0 +1 @@
+*.cxx

src/basis_factorization/AlmostIdentityMatrix.h

@@ -18,19 +18,29 @@
 class AlmostIdentityMatrix
 {
 public:
+    unsigned _row;
+    unsigned _column;
+    double _value;
+
     AlmostIdentityMatrix()
-        : _identity( true )
     {
     }
 
-    /*
-      True iff this is the identity matrix.
-    */
-    bool _identity;
+    AlmostIdentityMatrix( const AlmostIdentityMatrix &other )
+        : _row( other._row )
+        , _column( other._column )
+        , _value( other._value )
+    {
+    }
+
+    AlmostIdentityMatrix &operator=( const AlmostIdentityMatrix &other )
+    {
+        _row = other._row;
+        _column = other._column;
+        _value = other._value;
 
-    unsigned _row;
-    unsigned _column;
-    double _value;
+        return *this;
+    }
 };
 
 #endif // __AlmostIdentityMatrix_h__

src/basis_factorization/BasisFactorizationError.h

@@ -22,6 +22,8 @@ class BasisFactorizationError : public Error
         ALLOCATION_FAILED = 0,
         CANT_INVERT_BASIS_BECAUSE_OF_ETAS = 1,
         UNKNOWN_BASIS_FACTORIZATION_TYPE = 2,
+        CORRUPT_PERMUATION_MATRIX = 3,
+        CANT_INVERT_BASIS_BECAUSE_BASIS_ISNT_AVAILABLE = 4,
     };
 
     BasisFactorizationError( BasisFactorizationError::Code code ) :

src/basis_factorization/EtaMatrix.cpp

@@ -85,7 +85,7 @@ EtaMatrix::~EtaMatrix()
     }
 }
 
-void EtaMatrix::dump()
+void EtaMatrix::dump() const
 {
     printf( "Dumping eta matrix\n" );
     printf( "\tm = %u. column index = %u\n", _m, _columnIndex );

src/basis_factorization/EtaMatrix.h

@@ -27,7 +27,7 @@ class EtaMatrix
     EtaMatrix &operator=( const EtaMatrix &other );
 
     ~EtaMatrix();
-    void dump();
+    void dump() const;
 	void toMatrix( double *A );
 
     void resetToIdentity();