progress towards compiling

samitch · samitch · commit 52d463600d78 · 2020-02-05T18:17:23.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -22,3 +22,4 @@
 *.settings
 *ioss.doxygen.warn
 *ioss.tags
+UserInterfaceState.xcuserstate
diff --git a/Source/IA.cpp b/Source/IA.cpp
@@ -1,26 +1,29 @@
 // IA.cpp
 
 #include "IA.h"
-#include "IAImplementation.h"
+#include "IncrementalIntervalAssignment.h"
 #include <limits>
 
-
-IAResult::IAResult() : 
-solved(false), 
-constraints_satisfied(false), 
-bounds_satisfied(false), 
-optimized(false), 
-error(false)
-{}
-
-IAResult::IAResult() : ia( new IAImplementation()), free_row(0)
-{}
-
-virtual ~IAResult()
+namespace IIA
 {
-	delete IAImplementation;
-	IAImplementation = nullptr;
+  using IIA_Internal::IncrementalIntervalAssignment;
+  
+  IAResult::IAResult() :
+  solved(false),
+  constraints_satisfied(false),
+  bounds_satisfied(false),
+  optimized(false),
+  error(false)
+  {}
+  
+  IA::IA() : ia( new IncrementalIntervalAssignment()), free_row(0)
+  {}
+  
+  IA::~IA()
+  {
+    delete ia;
+    ia = nullptr;
+  }
+  
 }
 
-
-
diff --git a/Source/IA.h b/Source/IA.h
@@ -10,11 +10,16 @@
 #include <vector>
 #include <string>
 
-namespace IAInternal
+#include "IAEnums.h"
+
+namespace IIA_Internal
 {
-	class IAImplementation;	
+  class IncrementalIntervalAssignment;
 }
 
+namespace IIA
+{
+
 class IAResult
 {
 public:
@@ -122,9 +127,10 @@ class IA
 	const IAResult &get_result();
 
 private:
-	IAInternal::IAImplementation *ia;
+  IIA_Internal::IncrementalIntervalAssignment *ia;
 	int free_row;
 
 };
 
+} // namespace
 #endif
diff --git a/Source/IAEnums.h b/Source/IAEnums.h
@@ -0,0 +1,13 @@
+// IAEnums.h
+
+#ifndef IA_ENUMS_H
+#define IA_ENUMS_H
+
+namespace IIA
+{
+	enum ConstraintType {EQ, LE, GE, EVEN, BAD};
+	//                   ==, <=, >=, =2k,
+
+}
+
+#endif
diff --git a/Source/IncrementalIntervalAssignment.cpp b/Source/IncrementalIntervalAssignment.cpp
@@ -2,7 +2,7 @@
 #include "IncrementalIntervalAssignment.h"
 
 // to do
-//   move freeze_problem_size to start of solve, depending on whether solving for the first time or not
+//  x move freeze_problem_size to start of solve, depending on whether solving for the first time or not
 //   data layout for variables with goals and slack variables and sum-even vars... probably fast enough we can just go over all of them and check the goals. maybe need something to mark vars whose column coefficients are 2
 //   sum-even constraint conversion
 //   initialize goals to 1, bounds to 1,inf, etc.
@@ -20,8 +20,10 @@
 #include <numeric>
 
 // math utilities
+namespace IIA_Internal
+{
 
-// greatest common divisor of u and v
+  // greatest common divisor of u and v
 // always returns a positive number, as we take abs of u and v
 int gcd(int u, int v)
 {
@@ -5345,7 +5347,7 @@ int IncrementalIntervalAssignment::new_row(MRow &Mrow)
   return used_row;
 }
 
-void IncrementalIntervalAssignment::freeze_problem_size( int /*is_equality_subprogram*/ )
+void IncrementalIntervalAssignment::freeze_problem_size()
 {
   // zzyk to do: ensure we are told how many there are going to be
   // reserve extra space for dynamic u-sub variables and rows
@@ -5632,7 +5634,7 @@ int IncrementalIntervalAssignment::solve_sub(int create_infeasible_groups)
     // generate the upper/lower bounds/goals for the tied-to variables
     if (!generate_tied_data())
     {
-      return CUBIT_FALSE;
+      return false;
     }
 
     // adjust the initial solution for the tied-to variables
@@ -5788,7 +5790,7 @@ int IncrementalIntervalAssignment::solve_sub(int create_infeasible_groups)
   
   if (!in_bounds)
   {
-    return CUBIT_FALSE;
+    return false;
   }
   
   hasBeenSolved=true; // feasible solution
@@ -5876,6 +5878,8 @@ int IncrementalIntervalAssignment::solve(int create_groups,
   double setup_time=0, map_time(0.);
   if (first_time)
   {
+    freeze_problem_size();
+    
     int num_converted=0;
     for (int r = 0; r <= used_row; ++r)
     {
@@ -5974,7 +5978,7 @@ int IncrementalIntervalAssignment::solve(int create_groups,
   {
     if (!do_pave)
     {
-      success = CUBIT_FALSE;
+      success = false;
     }
     else
     {
@@ -6049,13 +6053,13 @@ int IntervalProblem::solve_map(int create_groups,
   
   // subdivide non-sum-even problems into independent components
   std::vector<IntervalProblem*> sub_problems;
-  subdivide_problem( sub_problems, CUBIT_FALSE, row_min, row_max  );
+  subdivide_problem( sub_problems, false, row_min, row_max  );
   const int num_subs = sub_problems.size();
   
   double solve_time=0.;
   CpuTimer solve_timer;
   
-  int success = CUBIT_TRUE;
+  int success = true;
   for ( int i = num_subs; i--; )
   {
     auto *sub_problem = sub_problems.get_and_step();
@@ -6064,13 +6068,13 @@ int IntervalProblem::solve_map(int create_groups,
     {
       PRINT_DEBUG_121("Mapping subproblem %d of %d:\n",
                       num_subs - i, num_subs);
-      sub_problem->summarize_problem( CUBIT_FALSE, CUBIT_TRUE );
+      sub_problem->summarize_problem( false, true );
     }
     if ( !report_only )
     {
       if (sub_problem->solve_sub( create_infeasible_groups) != CUBIT_SUCCESS)
       {
-        success = CUBIT_FALSE;
+        success = false;
         if (printFlag)
         {
           PRINT_WARNING("Mapping subproblem %d of %d was infeasible.\n",
@@ -6116,23 +6120,23 @@ int IntervalProblem::solve_even(int create_groups,
   // subdivide based on sum-even constraints.
   // Some equality constraints may not be used
   std::vector<IntervalProblem*> sub_problems;
-  subdivide_problem( sub_problems, CUBIT_TRUE, row_min, row_max );
+  subdivide_problem( sub_problems, true, row_min, row_max );
   const int num_subs = sub_problems.size();
   
-  int success = CUBIT_TRUE;
+  int success = true;
   for ( int i = sub_problems.size(); i--; )
   {
     auto *sub_problem = sub_problems.get_and_step();
     
     if ( create_groups ) {
       PRINT_DEBUG_121("Sum-even (Paving) subproblem %d of %d:\n",
                       num_subs - i, num_subs);
-      sub_problem->summarize_problem( CUBIT_FALSE, CUBIT_TRUE );
+      sub_problem->summarize_problem( false, true );
     }
     if ( !report_only ) {
       if ( sub_problem->solve_sub_even() == CUBIT_FAILURE )
       {
-        success = CUBIT_FALSE;
+        success = false;
         // create a group for the infeasible subproblem
         if (printFlag)
           PRINT_WARNING("Interval Matching subproblem is infeasible\n");
@@ -6443,7 +6447,7 @@ void IntervalProblem::recursively_add_edge( int int_var_column,
   assert( !sub_cols.is_in_list( int_var_column+1 ) ); //no side-effects
   assert( !sub_col_array[ int_var_column ] );
   sub_cols.append( int_var_column+1 );
-  sub_col_array[ int_var_column ] = CUBIT_TRUE;
+  sub_col_array[ int_var_column ] = true;
 
   auto &non_zeros = col_rows[int_var_column];
   int row, cross_column;
@@ -6455,15 +6459,15 @@ void IntervalProblem::recursively_add_edge( int int_var_column,
       auto &row_non_zeros = rows[row].cols;
 
         // should we add this row?
-      int do_add = CUBIT_FALSE;
+      int do_add = false;
       if ( do_sum_even ) 
       {
-        do_add = CUBIT_TRUE;
+        do_add = true;
       }
       else {
 
           // is the row a sum-even row?
-        int has_sum_even_var = CUBIT_FALSE;
+        int has_sum_even_var = false;
         row_non_zeros.last();
         {
           for ( int j = row_non_zeros.size(); j--; ) {
@@ -6472,15 +6476,15 @@ void IntervalProblem::recursively_add_edge( int int_var_column,
                  cross_column < num_int_vars() + sumEvenDummies )
             {
               PRINT_DEBUG(47,"IntervalProblem::recursively_add_edge: column %d is a sum-even because it's index is in [%d,%d), so skipping row %d.\n", cross_column,num_int_vars(),num_int_vars() + sumEvenDummies, row );
-              has_sum_even_var = CUBIT_TRUE;
+              has_sum_even_var = true;
               break;
             }
           }
         }
           // and if is an equality constraint row
         if ( !has_sum_even_var ) 
         {
-          do_add = CUBIT_TRUE;
+          do_add = true;
         }
       }
       
@@ -6536,14 +6540,14 @@ void IntervalProblem::recursively_add_edge( int int_var_column,
             // Below: can skip the row on the bet that intervals won't decrease by more than a factor of 2.
             abs(expected_edge_count) <= 2*abs(sum_even_min) )
         {
-          do_add = CUBIT_TRUE;
+          do_add = true;
         }
       }
       
       // add row to sub problem
       if ( do_add ) {
         sub_rows.append( row+1 );
-        sub_row_array[ row ] = CUBIT_TRUE;
+        sub_row_array[ row ] = true;
         
           // recursively add cross-columns
         for ( int k = row_non_zeros.size(); k--; )
@@ -6722,7 +6726,7 @@ void IntervalProblem::subdivide_problem(std::vector<IntervalProblem*> &sub_probl
       int sub_edges = sub_problem->num_int_vars();
       sub_problem->lastCopiedCol = sub_edges + sub_problem->numDummies;
 
-      sub_problem->freeze_problem_size( !do_sum_even );
+      sub_problem->freeze_problem_size();
       
         // title, for debugging
       if (names_exist())
@@ -7167,3 +7171,5 @@ bool IntervalProblem::verify_full_solution(bool print_unsatisfied_constraints)
   }
   return rc;
 }
+
+} // namespace
diff --git a/Source/IncrementalIntervalAssignment.h b/Source/IncrementalIntervalAssignment.h

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`#include "IncrementalIntervalAssignment.h"`
`3`	`3`
`4`	`4`	`// to do`
`5`		`-// move freeze_problem_size to start of solve, depending on whether solving for the first time or not`
	`5`	`+// x move freeze_problem_size to start of solve, depending on whether solving for the first time or not`
`6`	`6`	`// data layout for variables with goals and slack variables and sum-even vars... probably fast enough we can just go over all of them and check the goals. maybe need something to mark vars whose column coefficients are 2`
`7`	`7`	`// sum-even constraint conversion`
`8`	`8`	`// initialize goals to 1, bounds to 1,inf, etc.`
`@@ -20,8 +20,10 @@`
`20`	`20`	`#include <numeric>`
`21`	`21`
`22`	`22`	`// math utilities`
	`23`	`+namespace IIA_Internal`
	`24`	`+{`
`23`	`25`
`24`		`-// greatest common divisor of u and v`
	`26`	`+ // greatest common divisor of u and v`
`25`	`27`	`// always returns a positive number, as we take abs of u and v`
`26`	`28`	`int gcd(int u, int v)`
`27`	`29`	`{`
`@@ -5345,7 +5347,7 @@ int IncrementalIntervalAssignment::new_row(MRow &Mrow)`
`5345`	`5347`	`return used_row;`
`5346`	`5348`	`}`
`5347`	`5349`
`5348`		`-void IncrementalIntervalAssignment::freeze_problem_size( int /is_equality_subprogram/ )`
	`5350`	`+void IncrementalIntervalAssignment::freeze_problem_size()`
`5349`	`5351`	`{`
`5350`	`5352`	`// zzyk to do: ensure we are told how many there are going to be`
`5351`	`5353`	`// reserve extra space for dynamic u-sub variables and rows`
`@@ -5632,7 +5634,7 @@ int IncrementalIntervalAssignment::solve_sub(int create_infeasible_groups)`
`5632`	`5634`	`// generate the upper/lower bounds/goals for the tied-to variables`
`5633`	`5635`	`if (!generate_tied_data())`
`5634`	`5636`	`{`
`5635`		`- return CUBIT_FALSE;`
	`5637`	`+ return false;`
`5636`	`5638`	`}`
`5637`	`5639`
`5638`	`5640`	`// adjust the initial solution for the tied-to variables`
`@@ -5788,7 +5790,7 @@ int IncrementalIntervalAssignment::solve_sub(int create_infeasible_groups)`
`5788`	`5790`
`5789`	`5791`	`if (!in_bounds)`
`5790`	`5792`	`{`
`5791`		`- return CUBIT_FALSE;`
	`5793`	`+ return false;`
`5792`	`5794`	`}`
`5793`	`5795`
`5794`	`5796`	`hasBeenSolved=true; // feasible solution`
`@@ -5876,6 +5878,8 @@ int IncrementalIntervalAssignment::solve(int create_groups,`
`5876`	`5878`	`double setup_time=0, map_time(0.);`
`5877`	`5879`	`if (first_time)`
`5878`	`5880`	`{`
	`5881`	`+ freeze_problem_size();`
	`5882`	`+`
`5879`	`5883`	`int num_converted=0;`
`5880`	`5884`	`for (int r = 0; r <= used_row; ++r)`
`5881`	`5885`	`{`
`@@ -5974,7 +5978,7 @@ int IncrementalIntervalAssignment::solve(int create_groups,`
`5974`	`5978`	`{`
`5975`	`5979`	`if (!do_pave)`
`5976`	`5980`	`{`
`5977`		`- success = CUBIT_FALSE;`
	`5981`	`+ success = false;`
`5978`	`5982`	`}`
`5979`	`5983`	`else`
`5980`	`5984`	`{`
`@@ -6049,13 +6053,13 @@ int IntervalProblem::solve_map(int create_groups,`
`6049`	`6053`
`6050`	`6054`	`// subdivide non-sum-even problems into independent components`
`6051`	`6055`	`std::vector<IntervalProblem*> sub_problems;`
`6052`		`- subdivide_problem( sub_problems, CUBIT_FALSE, row_min, row_max );`
	`6056`	`+ subdivide_problem( sub_problems, false, row_min, row_max );`
`6053`	`6057`	`const int num_subs = sub_problems.size();`
`6054`	`6058`
`6055`	`6059`	`double solve_time=0.;`
`6056`	`6060`	`CpuTimer solve_timer;`
`6057`	`6061`
`6058`		`- int success = CUBIT_TRUE;`
	`6062`	`+ int success = true;`
`6059`	`6063`	`for ( int i = num_subs; i--; )`
`6060`	`6064`	`{`
`6061`	`6065`	`auto *sub_problem = sub_problems.get_and_step();`
`@@ -6064,13 +6068,13 @@ int IntervalProblem::solve_map(int create_groups,`
`6064`	`6068`	`{`
`6065`	`6069`	`PRINT_DEBUG_121("Mapping subproblem %d of %d:\n",`
`6066`	`6070`	`num_subs - i, num_subs);`
`6067`		`- sub_problem->summarize_problem( CUBIT_FALSE, CUBIT_TRUE );`
	`6071`	`+ sub_problem->summarize_problem( false, true );`
`6068`	`6072`	`}`
`6069`	`6073`	`if ( !report_only )`
`6070`	`6074`	`{`
`6071`	`6075`	`if (sub_problem->solve_sub( create_infeasible_groups) != CUBIT_SUCCESS)`
`6072`	`6076`	`{`
`6073`		`- success = CUBIT_FALSE;`
	`6077`	`+ success = false;`
`6074`	`6078`	`if (printFlag)`
`6075`	`6079`	`{`
`6076`	`6080`	`PRINT_WARNING("Mapping subproblem %d of %d was infeasible.\n",`
`@@ -6116,23 +6120,23 @@ int IntervalProblem::solve_even(int create_groups,`
`6116`	`6120`	`// subdivide based on sum-even constraints.`
`6117`	`6121`	`// Some equality constraints may not be used`
`6118`	`6122`	`std::vector<IntervalProblem*> sub_problems;`
`6119`		`- subdivide_problem( sub_problems, CUBIT_TRUE, row_min, row_max );`
	`6123`	`+ subdivide_problem( sub_problems, true, row_min, row_max );`
`6120`	`6124`	`const int num_subs = sub_problems.size();`
`6121`	`6125`
`6122`		`- int success = CUBIT_TRUE;`
	`6126`	`+ int success = true;`
`6123`	`6127`	`for ( int i = sub_problems.size(); i--; )`
`6124`	`6128`	`{`
`6125`	`6129`	`auto *sub_problem = sub_problems.get_and_step();`
`6126`	`6130`
`6127`	`6131`	`if ( create_groups ) {`
`6128`	`6132`	`PRINT_DEBUG_121("Sum-even (Paving) subproblem %d of %d:\n",`
`6129`	`6133`	`num_subs - i, num_subs);`
`6130`		`- sub_problem->summarize_problem( CUBIT_FALSE, CUBIT_TRUE );`
	`6134`	`+ sub_problem->summarize_problem( false, true );`
`6131`	`6135`	`}`
`6132`	`6136`	`if ( !report_only ) {`
`6133`	`6137`	`if ( sub_problem->solve_sub_even() == CUBIT_FAILURE )`
`6134`	`6138`	`{`
`6135`		`- success = CUBIT_FALSE;`
	`6139`	`+ success = false;`
`6136`	`6140`	`// create a group for the infeasible subproblem`
`6137`	`6141`	`if (printFlag)`
`6138`	`6142`	`PRINT_WARNING("Interval Matching subproblem is infeasible\n");`
`@@ -6443,7 +6447,7 @@ void IntervalProblem::recursively_add_edge( int int_var_column,`
`6443`	`6447`	`assert( !sub_cols.is_in_list( int_var_column+1 ) ); //no side-effects`
`6444`	`6448`	`assert( !sub_col_array[ int_var_column ] );`
`6445`	`6449`	`sub_cols.append( int_var_column+1 );`
`6446`		`- sub_col_array[ int_var_column ] = CUBIT_TRUE;`
	`6450`	`+ sub_col_array[ int_var_column ] = true;`
`6447`	`6451`
`6448`	`6452`	`auto &non_zeros = col_rows[int_var_column];`
`6449`	`6453`	`int row, cross_column;`
`@@ -6455,15 +6459,15 @@ void IntervalProblem::recursively_add_edge( int int_var_column,`
`6455`	`6459`	`auto &row_non_zeros = rows[row].cols;`
`6456`	`6460`
`6457`	`6461`	`// should we add this row?`
`6458`		`- int do_add = CUBIT_FALSE;`
	`6462`	`+ int do_add = false;`
`6459`	`6463`	`if ( do_sum_even )`
`6460`	`6464`	`{`
`6461`		`- do_add = CUBIT_TRUE;`
	`6465`	`+ do_add = true;`
`6462`	`6466`	`}`
`6463`	`6467`	`else {`
`6464`	`6468`
`6465`	`6469`	`// is the row a sum-even row?`
`6466`		`- int has_sum_even_var = CUBIT_FALSE;`
	`6470`	`+ int has_sum_even_var = false;`
`6467`	`6471`	`row_non_zeros.last();`
`6468`	`6472`	`{`
`6469`	`6473`	`for ( int j = row_non_zeros.size(); j--; ) {`
`@@ -6472,15 +6476,15 @@ void IntervalProblem::recursively_add_edge( int int_var_column,`
`6472`	`6476`	`cross_column < num_int_vars() + sumEvenDummies )`
`6473`	`6477`	`{`
`6474`	`6478`	`PRINT_DEBUG(47,"IntervalProblem::recursively_add_edge: column %d is a sum-even because it's index is in [%d,%d), so skipping row %d.\n", cross_column,num_int_vars(),num_int_vars() + sumEvenDummies, row );`
`6475`		`- has_sum_even_var = CUBIT_TRUE;`
	`6479`	`+ has_sum_even_var = true;`
`6476`	`6480`	`break;`
`6477`	`6481`	`}`
`6478`	`6482`	`}`
`6479`	`6483`	`}`
`6480`	`6484`	`// and if is an equality constraint row`
`6481`	`6485`	`if ( !has_sum_even_var )`
`6482`	`6486`	`{`
`6483`		`- do_add = CUBIT_TRUE;`
	`6487`	`+ do_add = true;`
`6484`	`6488`	`}`
`6485`	`6489`	`}`
`6486`	`6490`
`@@ -6536,14 +6540,14 @@ void IntervalProblem::recursively_add_edge( int int_var_column,`
`6536`	`6540`	`// Below: can skip the row on the bet that intervals won't decrease by more than a factor of 2.`
`6537`	`6541`	`abs(expected_edge_count) <= 2*abs(sum_even_min) )`
`6538`	`6542`	`{`
`6539`		`- do_add = CUBIT_TRUE;`
	`6543`	`+ do_add = true;`
`6540`	`6544`	`}`
`6541`	`6545`	`}`
`6542`	`6546`
`6543`	`6547`	`// add row to sub problem`
`6544`	`6548`	`if ( do_add ) {`
`6545`	`6549`	`sub_rows.append( row+1 );`
`6546`		`- sub_row_array[ row ] = CUBIT_TRUE;`
	`6550`	`+ sub_row_array[ row ] = true;`
`6547`	`6551`
`6548`	`6552`	`// recursively add cross-columns`
`6549`	`6553`	`for ( int k = row_non_zeros.size(); k--; )`
`@@ -6722,7 +6726,7 @@ void IntervalProblem::subdivide_problem(std::vector<IntervalProblem*> &sub_probl`
`6722`	`6726`	`int sub_edges = sub_problem->num_int_vars();`
`6723`	`6727`	`sub_problem->lastCopiedCol = sub_edges + sub_problem->numDummies;`
`6724`	`6728`
`6725`		`- sub_problem->freeze_problem_size( !do_sum_even );`
	`6729`	`+ sub_problem->freeze_problem_size();`
`6726`	`6730`
`6727`	`6731`	`// title, for debugging`
`6728`	`6732`	`if (names_exist())`
`@@ -7167,3 +7171,5 @@ bool IntervalProblem::verify_full_solution(bool print_unsatisfied_constraints)`
`7167`	`7171`	`}`
`7168`	`7172`	`return rc;`
`7169`	`7173`	`}`
	`7174`	`+`
	`7175`	`+} // namespace`