mv util/lp to math/lp

Signed-off-by: Lev Nachmanson <levnach@hotmail.com>

src/math/lp/active_set.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 
 #pragma once
-#include "util/lp/binary_heap_priority_queue.h"
+#include "math/lp/binary_heap_priority_queue.h"
 namespace lp {
 class active_set {
     std::unordered_set<constraint*, constraint_hash, constraint_equal> m_cs;

src/math/lp/binary_heap_priority_queue.cpp

@@ -17,8 +17,8 @@ Revision History:
 
 
 --*/
-#include "util/lp/numeric_pair.h"
-#include "util/lp/binary_heap_priority_queue_def.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/binary_heap_priority_queue_def.h"
 namespace lp {
 template binary_heap_priority_queue<int>::binary_heap_priority_queue(unsigned int);
 template unsigned binary_heap_priority_queue<int>::dequeue();

src/math/lp/binary_heap_priority_queue.h

@@ -21,7 +21,7 @@ Revision History:
 #pragma once
 #include "util/vector.h"
 #include "util/debug.h"
-#include "util/lp/lp_utils.h"
+#include "math/lp/lp_utils.h"
 namespace lp {
 // the elements with the smallest priority are dequeued first
 template <typename T>

src/math/lp/binary_heap_priority_queue_def.h

@@ -18,7 +18,7 @@ Revision History:
 
 --*/
 #include "util/vector.h"
-#include "util/lp/binary_heap_priority_queue.h"
+#include "math/lp/binary_heap_priority_queue.h"
 namespace lp {
 // "i" is the child's place in the heap
 template <typename T> void binary_heap_priority_queue<T>::swap_with_parent(unsigned i) {

src/math/lp/binary_heap_upair_queue.cpp

@@ -17,7 +17,7 @@ Revision History:
 
 
 --*/
-#include "util/lp/binary_heap_upair_queue_def.h"
+#include "math/lp/binary_heap_upair_queue_def.h"
 namespace lp {
 template binary_heap_upair_queue<int>::binary_heap_upair_queue(unsigned int);
 template binary_heap_upair_queue<unsigned int>::binary_heap_upair_queue(unsigned int);

src/math/lp/binary_heap_upair_queue.h

@@ -25,7 +25,7 @@ Revision History:
 #include "util/vector.h"
 #include <set>
 #include <utility>
-#include "util/lp/binary_heap_priority_queue.h"
+#include "math/lp/binary_heap_priority_queue.h"
 
 
 typedef std::pair<unsigned, unsigned> upair;

src/math/lp/binary_heap_upair_queue_def.h

@@ -19,8 +19,8 @@ Revision History:
 --*/
 
 #include <set>
-#include "util/lp/lp_utils.h"
-#include "util/lp/binary_heap_upair_queue.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/binary_heap_upair_queue.h"
 namespace lp {
 template <typename T> binary_heap_upair_queue<T>::binary_heap_upair_queue(unsigned size) : m_q(size), m_pairs(size) {
     for (unsigned i = 0; i < size; i++)

src/math/lp/bound_analyzer_on_row.h

@@ -21,7 +21,7 @@ Revision History:
 #include "util/vector.h"
 #include "implied_bound.h"
 #include "test_bound_analyzer.h"
-#include "util/lp/bound_propagator.h"
+#include "math/lp/bound_propagator.h"
 // We have an equality : sum by j of row[j]*x[j] = rs
 // We try to pin a var by pushing the total by using the variable bounds
 // In a loop we drive the partial sum down, denoting the variables of this process by _u.

src/math/lp/bound_propagator.h

@@ -3,7 +3,7 @@
   Author: Lev Nachmanson
 */
 #pragma once
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 namespace lp {
 class lar_solver;
 class bound_propagator {

src/math/lp/column_info.h

@@ -23,7 +23,7 @@ Revision History:
 #include <unordered_map>
 #include <string>
 #include <algorithm>
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 namespace lp {
 inline bool is_valid(unsigned j) { return static_cast<int>(j) >= 0;}
 

src/math/lp/column_namer.h

@@ -19,7 +19,7 @@ Revision History:
 
 --*/
 #include <string>
-#include "util/lp/static_matrix.h"
+#include "math/lp/static_matrix.h"
 namespace lp {
 class column_namer {
 public:

src/math/lp/core_solver_pretty_printer.cpp

@@ -17,8 +17,8 @@ Revision History:
 
 
 --*/
-#include "util/lp/numeric_pair.h"
-#include "util/lp/core_solver_pretty_printer_def.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/core_solver_pretty_printer_def.h"
 template lp::core_solver_pretty_printer<double, double>::core_solver_pretty_printer(lp::lp_core_solver_base<double, double> &, std::ostream & out);
 template void lp::core_solver_pretty_printer<double, double>::print();
 template lp::core_solver_pretty_printer<double, double>::~core_solver_pretty_printer();

src/math/lp/core_solver_pretty_printer.h

@@ -23,8 +23,8 @@ Revision History:
 #include <algorithm>
 #include "util/vector.h"
 #include <ostream>
-#include "util/lp/lp_settings.h"
-#include "util/lp/indexed_vector.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/indexed_vector.h"
 namespace lp {
 template <typename T, typename X> class lp_core_solver_base; // forward definition
 

src/math/lp/core_solver_pretty_printer_def.h

@@ -20,10 +20,10 @@ Revision History:
 #include <limits>
 #include <string>
 #include <algorithm>
-#include "util/lp/lp_utils.h"
-#include "util/lp/lp_core_solver_base.h"
-#include "util/lp/core_solver_pretty_printer.h"
-#include "util/lp/numeric_pair.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/lp_core_solver_base.h"
+#include "math/lp/core_solver_pretty_printer.h"
+#include "math/lp/numeric_pair.h"
 namespace lp {
 
 

src/math/lp/dense_matrix.cpp

@@ -17,8 +17,8 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_settings.h"
-#include "util/lp/dense_matrix_def.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/dense_matrix_def.h"
 #ifdef Z3DEBUG
 #include "util/vector.h"
 template lp::dense_matrix<double, double> lp::operator*<double, double>(lp::matrix<double, double>&, lp::matrix<double, double>&);

src/math/lp/dense_matrix.h

@@ -20,7 +20,7 @@ Revision History:
 #pragma once
 #ifdef Z3DEBUG
 #include "util/vector.h"
-#include "util/lp/matrix.h"
+#include "math/lp/matrix.h"
 namespace lp {
 // used for debugging purposes only
 template <typename T, typename X>

src/math/lp/dense_matrix_def.h

@@ -17,11 +17,11 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 #ifdef Z3DEBUG
 #include "util/vector.h"
-#include "util/lp/numeric_pair.h"
-#include "util/lp/dense_matrix.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/dense_matrix.h"
 namespace lp {
 template <typename T, typename X> dense_matrix<T, X>::dense_matrix(unsigned m, unsigned n) : m_m(m), m_n(n), m_values(m * n, numeric_traits<T>::zero()) {
 }

src/math/lp/emonomials.cpp

@@ -19,9 +19,9 @@
 
   --*/
 
-#include "util/lp/emonomials.h"
-#include "util/lp/nla_defs.h"
-#include "util/lp/nla_core.h"
+#include "math/lp/emonomials.h"
+#include "math/lp/nla_defs.h"
+#include "math/lp/nla_core.h"
 
 namespace nla {
 

src/math/lp/emonomials.h

@@ -20,9 +20,9 @@
   --*/
 
 #pragma once
-#include "util/lp/lp_utils.h"
-#include "util/lp/var_eqs.h"
-#include "util/lp/monomial.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/var_eqs.h"
+#include "math/lp/monomial.h"
 #include "util/region.h"
 
 namespace nla {

src/math/lp/eta_matrix.cpp

@@ -19,8 +19,8 @@ Revision History:
 --*/
 #include <memory>
 #include "util/vector.h"
-#include "util/lp/numeric_pair.h"
-#include "util/lp/eta_matrix_def.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/eta_matrix_def.h"
 #ifdef Z3DEBUG
 template double lp::eta_matrix<double, double>::get_elem(unsigned int, unsigned int) const;
 template lp::mpq lp::eta_matrix<lp::mpq, lp::mpq>::get_elem(unsigned int, unsigned int) const;

src/math/lp/eta_matrix.h

@@ -20,8 +20,8 @@ Revision History:
 
 #pragma once
 #include "util/vector.h"
-#include "util/lp/tail_matrix.h"
-#include "util/lp/permutation_matrix.h"
+#include "math/lp/tail_matrix.h"
+#include "math/lp/permutation_matrix.h"
 namespace lp {
 
 // This is the sum of a unit matrix and a one-column matrix

src/math/lp/eta_matrix_def.h

@@ -20,7 +20,7 @@ Revision History:
 
 #pragma once
 #include "util/vector.h"
-#include "util/lp/eta_matrix.h"
+#include "math/lp/eta_matrix.h"
 namespace lp {
 
 // This is the sum of a unit matrix and a one-column matrix

src/math/lp/explanation.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 #pragma once
 #include <unordered_set>
-#include "util/lp/lp_utils.h"
+#include "math/lp/lp_utils.h"
 namespace lp {
 class explanation {
     vector<std::pair<mpq, constraint_index>> m_explanation;

src/math/lp/factorization.cpp

@@ -1,5 +1,5 @@
 #include "util/vector.h"
-#include "util/lp/factorization.h"
+#include "math/lp/factorization.h"
 namespace nla {
 
 void const_iterator_mon::init_vars_by_the_mask(unsigned_vector & k_vars, unsigned_vector & j_vars) const {

src/math/lp/factorization.h

@@ -20,8 +20,8 @@
   --*/
 #pragma once
 #include "util/rational.h"
-#include "util/lp/monomial.h"
-#include "util/lp/nla_defs.h"
+#include "math/lp/monomial.h"
+#include "math/lp/nla_defs.h"
 
 namespace nla {
 

src/math/lp/factorization_factory_imp.cpp

@@ -17,8 +17,8 @@
 
 
   --*/
-#include "util/lp/factorization_factory_imp.h"
-#include "util/lp/nla_core.h"
+#include "math/lp/factorization_factory_imp.h"
+#include "math/lp/nla_core.h"
 namespace nla {
         
 factorization_factory_imp::factorization_factory_imp(const monomial& rm, const core& s) :

src/math/lp/factorization_factory_imp.h

@@ -18,7 +18,7 @@
 
   --*/
 #pragma once
-#include "util/lp/factorization.h"
+#include "math/lp/factorization.h"
 namespace nla {
     class  core;
 

src/math/lp/gomory.cpp

@@ -17,10 +17,10 @@
 
 
   --*/
-#include "util/lp/gomory.h"
-#include "util/lp/int_solver.h"
-#include "util/lp/lar_solver.h"
-#include "util/lp/lp_utils.h"
+#include "math/lp/gomory.h"
+#include "math/lp/int_solver.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/lp_utils.h"
 namespace lp {
 
 class gomory::imp {

src/math/lp/gomory.h

@@ -16,10 +16,10 @@ Author:
 Revision History:
 --*/
 #pragma once
-#include "util/lp/lar_term.h"
-#include "util/lp/lia_move.h"
-#include "util/lp/explanation.h"
-#include "util/lp/static_matrix.h"
+#include "math/lp/lar_term.h"
+#include "math/lp/lia_move.h"
+#include "math/lp/explanation.h"
+#include "math/lp/static_matrix.h"
 
 namespace lp {
 class int_solver;

src/math/lp/hnf.h

@@ -27,7 +27,7 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/numeric_pair.h"
+#include "math/lp/numeric_pair.h"
 #include "util/ext_gcd.h"
 namespace lp {
 namespace hnf_calc {

src/math/lp/hnf_cutter.h

@@ -17,12 +17,12 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/lar_term.h"
-#include "util/lp/hnf.h"
-#include "util/lp/general_matrix.h"
-#include "util/lp/var_register.h"
-#include "util/lp/lia_move.h"
-#include "util/lp/explanation.h"
+#include "math/lp/lar_term.h"
+#include "math/lp/hnf.h"
+#include "math/lp/general_matrix.h"
+#include "math/lp/var_register.h"
+#include "math/lp/lia_move.h"
+#include "math/lp/explanation.h"
 
 namespace lp  {
 class hnf_cutter {

src/math/lp/implied_bound.h

@@ -18,8 +18,8 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/lp_settings.h"
-#include "util/lp/lar_constraints.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/lar_constraints.h"
 namespace lp {
 struct implied_bound {
     mpq m_bound;

src/math/lp/indexed_vector.cpp

@@ -18,7 +18,7 @@ Revision History:
 
 --*/
 #include "util/vector.h"
-#include "util/lp/indexed_vector_def.h"
+#include "math/lp/indexed_vector_def.h"
 namespace lp {
 template void indexed_vector<double>::clear();
 template void indexed_vector<double>::clear_all();

src/math/lp/indexed_vector.h

@@ -23,8 +23,8 @@ Revision History:
 #include "util/debug.h"
 #include <string>
 #include <iomanip>
-#include "util/lp/lp_utils.h"
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/lp_settings.h"
 #include <unordered_set>
 namespace lp {
 

src/math/lp/indexed_vector_def.h

@@ -18,8 +18,8 @@ Revision History:
 
 --*/
 #include "util/vector.h"
-#include "util/lp/indexed_vector.h"
-#include "util/lp/lp_settings.h"
+#include "math/lp/indexed_vector.h"
+#include "math/lp/lp_settings.h"
 namespace lp {
 
 template <typename T>

src/math/lp/indexer_of_constraints.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 
 #pragma once
-#include "util/lp/binary_heap_priority_queue.h"
+#include "math/lp/binary_heap_priority_queue.h"
 namespace lp {
 
 class indexer_of_constraints {

src/math/lp/int_set.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 #pragma once
 #include "util/vector.h"
-#include "util/lp/indexed_vector.h"
+#include "math/lp/indexed_vector.h"
 #include <ostream>
 namespace lp {
 // serves at a set of non-negative integers smaller than the set size

src/math/lp/int_solver.cpp

@@ -3,12 +3,12 @@
   Author: Lev Nachmanson
 */
 
-#include "util/lp/int_solver.h"
-#include "util/lp/lar_solver.h"
-#include "util/lp/lp_utils.h"
+#include "math/lp/int_solver.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/lp_utils.h"
 #include <utility>
-#include "util/lp/monomial.h"
-#include "util/lp/gomory.h"
+#include "math/lp/monomial.h"
+#include "math/lp/gomory.h"
 namespace lp {
 
 

src/math/lp/int_solver.h

@@ -18,14 +18,14 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/lp_settings.h"
-#include "util/lp/static_matrix.h"
-#include "util/lp/int_set.h"
-#include "util/lp/lar_term.h"
-#include "util/lp/lar_constraints.h"
-#include "util/lp/hnf_cutter.h"
-#include "util/lp/lia_move.h"
-#include "util/lp/explanation.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/static_matrix.h"
+#include "math/lp/int_set.h"
+#include "math/lp/lar_term.h"
+#include "math/lp/lar_constraints.h"
+#include "math/lp/hnf_cutter.h"
+#include "math/lp/lia_move.h"
+#include "math/lp/explanation.h"
 
 namespace lp {
 class lar_solver;

src/math/lp/lar_constraints.h

@@ -24,9 +24,9 @@ Revision History:
 #include <unordered_map>
 #include <string>
 #include <algorithm>
-#include "util/lp/lp_utils.h"
-#include "util/lp/ul_pair.h"
-#include "util/lp/lar_term.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/ul_pair.h"
+#include "math/lp/lar_term.h"
 namespace lp {
 inline lconstraint_kind flip_kind(lconstraint_kind t) {
     return static_cast<lconstraint_kind>( - static_cast<int>(t));

src/math/lp/lar_core_solver.cpp

@@ -22,4 +22,4 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include <functional>
-#include "util/lp/lar_core_solver_def.h"
+#include "math/lp/lar_core_solver_def.h"

src/math/lp/lar_core_solver.h

@@ -21,15 +21,15 @@ Revision History:
 #include "util/vector.h"
 #include <string>
 #include <utility>
-#include "util/lp/lp_core_solver_base.h"
+#include "math/lp/lp_core_solver_base.h"
 #include <algorithm>
-#include "util/lp/indexed_vector.h"
-#include "util/lp/binary_heap_priority_queue.h"
-#include "util/lp/breakpoint.h"
-#include "util/lp/lp_primal_core_solver.h"
-#include "util/lp/stacked_vector.h"
-#include "util/lp/lar_solution_signature.h"
-#include "util/lp/stacked_value.h"
+#include "math/lp/indexed_vector.h"
+#include "math/lp/binary_heap_priority_queue.h"
+#include "math/lp/breakpoint.h"
+#include "math/lp/lp_primal_core_solver.h"
+#include "math/lp/stacked_vector.h"
+#include "math/lp/lar_solution_signature.h"
+#include "math/lp/stacked_value.h"
 namespace lp {
 
 class lar_core_solver  {

src/math/lp/lar_core_solver_def.h

@@ -38,8 +38,8 @@ Revision History:
 --*/
 #include <string>
 #include "util/vector.h"
-#include "util/lp/lar_core_solver.h"
-#include "util/lp/lar_solution_signature.h"
+#include "math/lp/lar_core_solver.h"
+#include "math/lp/lar_solution_signature.h"
 namespace lp {
 lar_core_solver::lar_core_solver(
                                  lp_settings & settings,

src/math/lp/lar_solution_signature.h

@@ -21,7 +21,7 @@ Revision History:
 #pragma once
 #include "util/vector.h"
 #include "util/debug.h"
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 #include <unordered_map>
 namespace lp {
 typedef std::unordered_map<unsigned, non_basic_column_value_position> lar_solution_signature;

src/math/lp/lar_solver.cpp

@@ -1,4 +1,4 @@
-#include "util/lp/lar_solver.h"
+#include "math/lp/lar_solver.h"
 /*
   Copyright (c) 2017 Microsoft Corporation
   Author: Nikolaj Bjorner, Lev Nachmanson

src/math/lp/lar_solver.h

@@ -25,23 +25,23 @@ Revision History:
 #include <unordered_map>
 #include <unordered_set>
 #include <string>
-#include "util/lp/lar_constraints.h"
+#include "math/lp/lar_constraints.h"
 #include <functional>
-#include "util/lp/lar_core_solver.h"
+#include "math/lp/lar_core_solver.h"
 #include <algorithm>
-#include "util/lp/numeric_pair.h"
-#include "util/lp/scaler.h"
-#include "util/lp/lp_primal_core_solver.h"
-#include "util/lp/random_updater.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/scaler.h"
+#include "math/lp/lp_primal_core_solver.h"
+#include "math/lp/random_updater.h"
 #include <stack>
-#include "util/lp/stacked_value.h"
-#include "util/lp/stacked_vector.h"
-#include "util/lp/implied_bound.h"
-#include "util/lp/bound_analyzer_on_row.h"
-#include "util/lp/conversion_helper.h"
-#include "util/lp/int_solver.h"
-#include "util/lp/nra_solver.h"
-#include "util/lp/bound_propagator.h"
+#include "math/lp/stacked_value.h"
+#include "math/lp/stacked_vector.h"
+#include "math/lp/implied_bound.h"
+#include "math/lp/bound_analyzer_on_row.h"
+#include "math/lp/conversion_helper.h"
+#include "math/lp/int_solver.h"
+#include "math/lp/nra_solver.h"
+#include "math/lp/bound_propagator.h"
 
 namespace lp {
 

src/math/lp/lar_term.h

@@ -18,7 +18,7 @@
 
   --*/
 #pragma once
-#include "util/lp/indexed_vector.h"
+#include "math/lp/indexed_vector.h"
 #include "util/map.h"
 namespace lp {
 class lar_term {

src/math/lp/lp_bound_propagator.cpp

@@ -2,7 +2,7 @@
   Copyright (c) 2017 Microsoft Corporation
   Author: Lev Nachmanson
 */
-#include "util/lp/lar_solver.h"
+#include "math/lp/lar_solver.h"
 namespace lp {
 bound_propagator::bound_propagator(lar_solver & ls):
     m_lar_solver(ls) {}

src/math/lp/lp_core_solver_base.cpp

@@ -22,7 +22,7 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include <functional>
-#include "util/lp/lp_core_solver_base_def.h"
+#include "math/lp/lp_core_solver_base_def.h"
 template bool lp::lp_core_solver_base<double, double>::A_mult_x_is_off() const;
 template bool lp::lp_core_solver_base<double, double>::A_mult_x_is_off_on_index(const vector<unsigned> &) const;
 template bool lp::lp_core_solver_base<double, double>::basis_heading_is_correct() const;

src/math/lp/lp_core_solver_base.h

@@ -21,13 +21,13 @@ Revision History:
 #include <set>
 #include "util/vector.h"
 #include <string>
-#include "util/lp/lp_utils.h"
-#include "util/lp/core_solver_pretty_printer.h"
-#include "util/lp/numeric_pair.h"
-#include "util/lp/static_matrix.h"
-#include "util/lp/lu.h"
-#include "util/lp/permutation_matrix.h"
-#include "util/lp/column_namer.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/core_solver_pretty_printer.h"
+#include "math/lp/numeric_pair.h"
+#include "math/lp/static_matrix.h"
+#include "math/lp/lu.h"
+#include "math/lp/permutation_matrix.h"
+#include "math/lp/column_namer.h"
 
 namespace lp {
 

src/math/lp/lp_core_solver_base_def.h

@@ -20,8 +20,8 @@ Revision History:
 #include <set>
 #include <string>
 #include "util/vector.h"
-#include "util/lp/lp_utils.h"
-#include "util/lp/lp_core_solver_base.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/lp_core_solver_base.h"
 namespace lp {
 
 template <typename T, typename X> lp_core_solver_base<T, X>::

src/math/lp/lp_dual_core_solver.cpp

@@ -22,7 +22,7 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include <functional>
-#include "util/lp/lp_dual_core_solver_def.h"
+#include "math/lp/lp_dual_core_solver_def.h"
 template void lp::lp_dual_core_solver<lp::mpq, lp::mpq>::start_with_initial_basis_and_make_it_dual_feasible();
 template void lp::lp_dual_core_solver<lp::mpq, lp::mpq>::solve();
 template lp::lp_dual_core_solver<double, double>::lp_dual_core_solver(lp::static_matrix<double, double>&, vector<bool>&,

src/math/lp/lp_dual_core_solver.h

@@ -18,8 +18,8 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/static_matrix.h"
-#include "util/lp/lp_core_solver_base.h"
+#include "math/lp/static_matrix.h"
+#include "math/lp/lp_core_solver_base.h"
 #include <string>
 #include <limits>
 #include <set>

src/math/lp/lp_dual_core_solver_def.h

@@ -20,7 +20,7 @@ Revision History:
 #include <algorithm>
 #include <string>
 #include "util/vector.h"
-#include "util/lp/lp_dual_core_solver.h"
+#include "math/lp/lp_dual_core_solver.h"
 
 namespace lp {
 

src/math/lp/lp_dual_simplex.cpp

@@ -17,7 +17,7 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_dual_simplex_def.h"
+#include "math/lp/lp_dual_simplex_def.h"
 template lp::mpq lp::lp_dual_simplex<lp::mpq, lp::mpq>::get_current_cost() const;
 template void lp::lp_dual_simplex<lp::mpq, lp::mpq>::find_maximal_solution();
 template double lp::lp_dual_simplex<double, double>::get_current_cost() const;

src/math/lp/lp_dual_simplex.h

@@ -19,9 +19,9 @@ Revision History:
 --*/
 #pragma once
 #include "util/vector.h"
-#include "util/lp/lp_utils.h"
-#include "util/lp/lp_solver.h"
-#include "util/lp/lp_dual_core_solver.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/lp_solver.h"
+#include "math/lp/lp_dual_core_solver.h"
 namespace lp {
 
 template <typename T, typename X>

src/math/lp/lp_dual_simplex_def.h

@@ -17,7 +17,7 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_dual_simplex.h"
+#include "math/lp/lp_dual_simplex.h"
 namespace lp{
 
 template <typename T, typename X> void lp_dual_simplex<T, X>::decide_on_status_after_stage1() {

src/math/lp/lp_primal_core_solver.cpp

@@ -22,9 +22,9 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include <functional>
-#include "util/lp/lar_solver.h"
-#include "util/lp/lp_primal_core_solver_def.h"
-#include "util/lp/lp_primal_core_solver_tableau_def.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/lp_primal_core_solver_def.h"
+#include "math/lp/lp_primal_core_solver_tableau_def.h"
 namespace lp {
 
 template void lp_primal_core_solver<double, double>::find_feasible_solution();

src/math/lp/lp_primal_core_solver.h

@@ -29,14 +29,14 @@ Revision History:
 #include <math.h>
 #include <cstdlib>
 #include <algorithm>
-#include "util/lp/lu.h"
-#include "util/lp/lp_solver.h"
-#include "util/lp/static_matrix.h"
-#include "util/lp/core_solver_pretty_printer.h"
-#include "util/lp/lp_core_solver_base.h"
-#include "util/lp/breakpoint.h"
-#include "util/lp/binary_heap_priority_queue.h"
-#include "util/lp/int_set.h"
+#include "math/lp/lu.h"
+#include "math/lp/lp_solver.h"
+#include "math/lp/static_matrix.h"
+#include "math/lp/core_solver_pretty_printer.h"
+#include "math/lp/lp_core_solver_base.h"
+#include "math/lp/breakpoint.h"
+#include "math/lp/binary_heap_priority_queue.h"
+#include "math/lp/int_set.h"
 namespace lp {
 
 // This core solver solves (Ax=b, lower_bound_values \leq x \leq upper_bound_values, maximize costs*x )

src/math/lp/lp_primal_core_solver_def.h

@@ -23,7 +23,7 @@ Revision History:
 #include <algorithm>
 #include <set>
 #include <string>
-#include "util/lp/lp_primal_core_solver.h"
+#include "math/lp/lp_primal_core_solver.h"
 namespace lp {
 // This core solver solves (Ax=b, lower_bound_values \leq x \leq upper_bound_values, maximize costs*x )
 // The right side b is given implicitly by x and the basis

src/math/lp/lp_primal_core_solver_tableau_def.h

@@ -18,7 +18,7 @@ Revision History:
 
 --*/
 // this is a part of lp_primal_core_solver that deals with the tableau
-#include "util/lp/lp_primal_core_solver.h"
+#include "math/lp/lp_primal_core_solver.h"
 namespace lp {
 template <typename T, typename X> void lp_primal_core_solver<T, X>::one_iteration_tableau() {
     int entering = choose_entering_column_tableau();

src/math/lp/lp_primal_simplex.cpp

@@ -22,7 +22,7 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include <functional>
-#include "util/lp/lp_primal_simplex_def.h"
+#include "math/lp/lp_primal_simplex_def.h"
 template bool lp::lp_primal_simplex<double, double>::bounds_hold(std::unordered_map<std::string, double, std::hash<std::string>, std::equal_to<std::string>, std::allocator<std::pair<std::string const, double> > > const&);
 template bool lp::lp_primal_simplex<double, double>::row_constraints_hold(std::unordered_map<std::string, double, std::hash<std::string>, std::equal_to<std::string>, std::allocator<std::pair<std::string const, double> > > const&);
 template double lp::lp_primal_simplex<double, double>::get_current_cost() const;

src/math/lp/lp_primal_simplex.h

@@ -22,10 +22,10 @@ Revision History:
 #include <unordered_map>
 #include <string>
 #include <algorithm>
-#include "util/lp/lp_utils.h"
-#include "util/lp/column_info.h"
-#include "util/lp/lp_primal_core_solver.h"
-#include "util/lp/lp_solver.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/column_info.h"
+#include "math/lp/lp_primal_core_solver.h"
+#include "math/lp/lp_solver.h"
 namespace lp {
 template <typename T, typename X>
 class lp_primal_simplex: public lp_solver<T, X> {

src/math/lp/lp_primal_simplex_def.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 #include <string>
 #include "util/vector.h"
-#include "util/lp/lp_primal_simplex.h"
+#include "math/lp/lp_primal_simplex.h"
 
 namespace lp {
 template <typename T, typename X> void lp_primal_simplex<T, X>::fill_costs_and_x_for_first_stage_solver(unsigned original_number_of_columns) {

src/math/lp/lp_settings.cpp

@@ -19,7 +19,7 @@ Revision History:
 --*/
 #include <memory>
 #include "util/vector.h"
-#include "util/lp/lp_settings_def.h"
+#include "math/lp/lp_settings_def.h"
 template bool lp::vectors_are_equal<double>(vector<double> const&, vector<double> const&);
 template bool lp::vectors_are_equal<lp::mpq>(vector<lp::mpq > const&, vector<lp::mpq> const&);
 

src/math/lp/lp_settings.h

@@ -24,9 +24,9 @@ Revision History:
 #include <algorithm>
 #include <limits>
 #include <iomanip>
-#include "util/lp/lp_utils.h"
+#include "math/lp/lp_utils.h"
 #include "util/stopwatch.h"
-#include "util/lp/lp_types.h"
+#include "math/lp/lp_types.h"
 
 namespace lp {
 

src/math/lp/lp_settings_def.h

@@ -20,7 +20,7 @@ Revision History:
 #include <cmath>
 #include <string>
 #include "util/vector.h"
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 namespace lp {
 std::string column_type_to_string(column_type t) {
     switch (t) {

src/math/lp/lp_solver.cpp

@@ -18,7 +18,7 @@ Revision History:
 
 --*/
 #include <string>
-#include "util/lp/lp_solver_def.h"
+#include "math/lp/lp_solver_def.h"
 template void lp::lp_solver<double, double>::add_constraint(lp::lp_relation, double, unsigned int);
 template void lp::lp_solver<double, double>::cleanup();
 template void lp::lp_solver<double, double>::count_slacks_and_artificials();

src/math/lp/lp_solver.h

@@ -23,12 +23,12 @@ Revision History:
 #include <unordered_map>
 #include <algorithm>
 #include "util/vector.h"
-#include "util/lp/lp_settings.h"
-#include "util/lp/column_info.h"
-#include "util/lp/static_matrix.h"
-#include "util/lp/lp_core_solver_base.h"
-#include "util/lp/scaler.h"
-#include "util/lp/bound_analyzer_on_row.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/column_info.h"
+#include "math/lp/static_matrix.h"
+#include "math/lp/lp_core_solver_base.h"
+#include "math/lp/scaler.h"
+#include "math/lp/bound_analyzer_on_row.h"
 namespace lp {
 enum lp_relation  {
     Less_or_equal,

src/math/lp/lp_solver_def.h

@@ -20,7 +20,7 @@ Revision History:
 #include <string>
 #include <algorithm>
 #include "util/vector.h"
-#include "util/lp/lp_solver.h"
+#include "math/lp/lp_solver.h"
 namespace lp {
 template <typename T, typename X> column_info<T> * lp_solver<T, X>::get_or_create_column_info(unsigned column) {
     auto it = m_map_from_var_index_to_column_info.find(column);

src/math/lp/lp_utils.cpp

@@ -17,7 +17,7 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_utils.h"
+#include "math/lp/lp_utils.h"
 #ifdef lp_for_z3
 namespace lp {
 double numeric_traits<double>::g_zero = 0.0;

src/math/lp/lp_utils.h

@@ -19,7 +19,7 @@ Revision History:
 --*/
 #pragma once
 #include <string>
-#include "util/lp/numeric_pair.h"
+#include "math/lp/numeric_pair.h"
 #include "util/debug.h"
 #include <unordered_map>
 #include <unordered_set>

src/math/lp/lu.cpp

@@ -22,7 +22,7 @@ Revision History:
 #include <string>
 #include "util/vector.h"
 #include "util/debug.h"
-#include "util/lp/lu_def.h"
+#include "math/lp/lu_def.h"
 namespace lp {
 template double dot_product<double, double>(vector<double> const&, vector<double> const&);
 template lu<static_matrix<double, double>>::lu(static_matrix<double, double> const&, vector<unsigned int>&, lp_settings&);

src/math/lp/lu.h

@@ -29,15 +29,15 @@ Revision History:
 #include "util/debug.h"
 #include <algorithm>
 #include <set>
-#include "util/lp/square_sparse_matrix.h"
-#include "util/lp/static_matrix.h"
+#include "math/lp/square_sparse_matrix.h"
+#include "math/lp/static_matrix.h"
 #include <string>
-#include "util/lp/numeric_pair.h"
+#include "math/lp/numeric_pair.h"
 #include <iostream>
 #include <fstream>
-#include "util/lp/row_eta_matrix.h"
-#include "util/lp/square_dense_submatrix.h"
-#include "util/lp/dense_matrix.h"
+#include "math/lp/row_eta_matrix.h"
+#include "math/lp/square_dense_submatrix.h"
+#include "math/lp/dense_matrix.h"
 namespace lp {
 template <typename T, typename X> // print the nr x nc submatrix at the top left corner
 void print_submatrix(square_sparse_matrix<T, X> & m, unsigned mr, unsigned nc);

src/math/lp/lu_def.h

@@ -23,7 +23,7 @@ Revision History:
 #include "util/vector.h"
 #include <utility>
 #include "util/debug.h"
-#include "util/lp/lu.h"
+#include "math/lp/lu.h"
 namespace lp {
 template <typename T, typename X, typename M> // print the nr x nc submatrix at the top left corner
 void print_submatrix(square_sparse_matrix<T, X> & m, unsigned mr, unsigned nc, std::ostream & out) {

src/math/lp/matrix.cpp

@@ -17,9 +17,9 @@ Revision History:
 
 
 --*/
-#include "util/lp/lp_settings.h"
-#include "util/lp/matrix_def.h"
-#include "util/lp/static_matrix.h"
+#include "math/lp/lp_settings.h"
+#include "math/lp/matrix_def.h"
+#include "math/lp/static_matrix.h"
 #include <string>
 #ifdef Z3DEBUG
 template bool lp::matrix<double, double>::is_equal(lp::matrix<double, double> const&);

src/math/lp/matrix.h

@@ -18,10 +18,10 @@ Revision History:
 
 --*/
 #pragma once
-#include "util/lp/numeric_pair.h"
+#include "math/lp/numeric_pair.h"
 #include "util/vector.h"
 #include <string>
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 namespace lp {
 // used for debugging purposes only
 template <typename T, typename X>

src/math/lp/matrix_def.h

@@ -20,7 +20,7 @@ Revision History:
 
 #include <cmath>
 #include <string>
-#include "util/lp/matrix.h"
+#include "math/lp/matrix.h"
 namespace lp {
 #ifdef Z3DEBUG
 template <typename T, typename X>

src/math/lp/mon_eq.cpp

@@ -2,8 +2,8 @@
   Copyright (c) 2017 Microsoft Corporation
   Author: Nikolaj Bjorner
 */
-#include "util/lp/lar_solver.h"
-#include "util/lp/monomial.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/monomial.h"
 namespace nla {
 
 template <typename T>

src/math/lp/monomial.h

@@ -5,10 +5,10 @@
       
 */
 #pragma once
-#include "util/lp/lp_settings.h"
+#include "math/lp/lp_settings.h"
 #include "util/vector.h"
-#include "util/lp/lar_solver.h"
-#include "util/lp/nla_defs.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/nla_defs.h"
 namespace nla {
 /*
  *  represents definition m_v = v1*v2*...*vn, 

src/math/lp/mps_reader.h

@@ -29,11 +29,11 @@ Revision History:
 #include <iostream>
 #include <fstream>
 #include <locale>
-#include "util/lp/lp_primal_simplex.h"
-#include "util/lp/lp_dual_simplex.h"
-#include "util/lp/lar_solver.h"
-#include "util/lp/lp_utils.h"
-#include "util/lp/lp_solver.h"
+#include "math/lp/lp_primal_simplex.h"
+#include "math/lp/lp_dual_simplex.h"
+#include "math/lp/lar_solver.h"
+#include "math/lp/lp_utils.h"
+#include "math/lp/lp_solver.h"
 namespace lp {
 inline bool my_white_space(const char & a) {
     return a == ' ' || a == '\t';

src/math/lp/nla_basics_lemmas.cpp

@@ -17,9 +17,9 @@
 
 
   --*/
-#include "util/lp/nla_basics_lemmas.h"
-#include "util/lp/nla_core.h"
-#include "util/lp/factorization_factory_imp.h"
+#include "math/lp/nla_basics_lemmas.h"
+#include "math/lp/nla_core.h"
+#include "math/lp/factorization_factory_imp.h"
 namespace nla {
 
 basics::basics(core * c) : common(c) {}

src/math/lp/nla_basics_lemmas.h

@@ -18,9 +18,9 @@
 
   --*/
 #pragma once
-#include "util/lp/monomial.h"    
-#include "util/lp/factorization.h"    
-#include "util/lp/nla_common.h"    
+#include "math/lp/monomial.h"    
+#include "math/lp/factorization.h"    
+#include "math/lp/nla_common.h"    
 
 
 namespace nla {

src/math/lp/nla_common.cpp

@@ -17,8 +17,8 @@
 
 
   --*/
-#include "util/lp/nla_common.h"
-#include "util/lp/nla_core.h"
+#include "math/lp/nla_common.h"
+#include "math/lp/nla_core.h"
 
 namespace nla {
 bool common::done() const { return c().done(); }

src/math/lp/nla_common.h

@@ -19,11 +19,11 @@
   --*/
 #pragma once
 #include "util/rational.h"
-#include "util/lp/nla_defs.h"
-#include "util/lp/lar_term.h"
-#include "util/lp/monomial.h"
-#include "util/lp/emonomials.h"
-#include "util/lp/factorization.h"
+#include "math/lp/nla_defs.h"
+#include "math/lp/lar_term.h"
+#include "math/lp/monomial.h"
+#include "math/lp/emonomials.h"
+#include "math/lp/factorization.h"
 namespace nla {
 
 

src/math/lp/nla_core.cpp

@@ -17,8 +17,8 @@ Revision History:
 
 
 --*/
-#include "util/lp/nla_core.h"
-#include "util/lp/factorization_factory_imp.h"
+#include "math/lp/nla_core.h"
+#include "math/lp/factorization_factory_imp.h"
 namespace nla {
 
 core::core(lp::lar_solver& s) :

src/math/lp/nla_core.h

@@ -18,14 +18,15 @@
 
   --*/
 #pragma once
-#include "util/lp/factorization.h"
-#include "util/lp/lp_types.h"
-#include "util/lp/var_eqs.h"
-#include "util/lp/nla_tangent_lemmas.h"
-#include "util/lp/nla_basics_lemmas.h"
-#include "util/lp/nla_order_lemmas.h"
-#include "util/lp/nla_monotone_lemmas.h"
-#include "util/lp/emonomials.h"
+#include "math/lp/factorization.h"
+#include "math/lp/lp_types.h"
+#include "math/lp/var_eqs.h"
+#include "math/lp/nla_tangent_lemmas.h"
+#include "math/lp/nla_basics_lemmas.h"
+#include "math/lp/nla_order_lemmas.h"
+#include "math/lp/nla_monotone_lemmas.h"
+#include "math/lp/emonomials.h"
+#include "math/lp/nla_settings.h"
 namespace nla {
 
 template <typename A, typename B>

src/math/lp/nla_defs.h

@@ -18,9 +18,9 @@
 
   --*/
 #pragma once
-#include "util/lp/lp_types.h"
-#include "util/lp/column_info.h"
-#include "util/lp/explanation.h"
+#include "math/lp/lp_types.h"
+#include "math/lp/column_info.h"
+#include "math/lp/explanation.h"
 
 namespace nla {
 typedef lp::constraint_index lpci;

src/math/lp/nla_monotone_lemmas.cpp

@@ -17,9 +17,9 @@
 
 
   --*/
-#include "util/lp/nla_basics_lemmas.h"
-#include "util/lp/nla_core.h"
-// #include "util/lp/factorization_factory_imp.h"
+#include "math/lp/nla_basics_lemmas.h"
+#include "math/lp/nla_core.h"
+// #include "math/lp/factorization_factory_imp.h"
 namespace nla {
 
 monotone::monotone(core * c) : common(c) {}