diff --git a/python/src/core/codac2_py_core.cpp b/python/src/core/codac2_py_core.cpp index fbee9d6d..a3f3c681 100644 --- a/python/src/core/codac2_py_core.cpp +++ b/python/src/core/codac2_py_core.cpp @@ -73,19 +73,19 @@ void export_Polygon(py::module& m); void export_arithmetic_add(py::module& m, py::class_& py_V, py::class_& py_IV, py::class_& py_M, py::class_& py_IM, - py::class_&,double>>& py_B, py::class_&,Interval>>& py_IB); + py::class_>& py_B, py::class_>& py_IB); void export_arithmetic_sub(py::module& m, py::class_& py_V, py::class_& py_IV, py::class_& py_M, py::class_& py_IM, - py::class_&,double>>& py_B, py::class_&,Interval>>& py_IB); + py::class_>& py_B, py::class_>& py_IB); void export_arithmetic_mul(py::module& m, py::class_& py_V, py::class_& py_IV, py::class_& py_M, py::class_& py_IM, - py::class_&,double>>& py_B, py::class_&,Interval>>& py_IB); + py::class_>& py_B, py::class_>& py_IB); void export_arithmetic_div(py::module& m, py::class_& py_V, py::class_& py_IV, py::class_& py_M, py::class_& py_IM, - py::class_&,double>>& py_B, py::class_&,Interval>>& py_IB); + py::class_>& py_B, py::class_>& py_IB); py::class_ export_Vector(py::module& m); py::class_ export_Matrix(py::module& m); diff --git a/python/src/core/domains/interval/codac2_py_IntervalMatrix.cpp b/python/src/core/domains/interval/codac2_py_IntervalMatrix.cpp index feeb208e..bf337d78 100644 --- a/python/src/core/domains/interval/codac2_py_IntervalMatrix.cpp +++ b/python/src/core/domains/interval/codac2_py_IntervalMatrix.cpp @@ -65,11 +65,11 @@ py::class_ export_IntervalMatrix(py::module& m) INTERVALMATRIX_INTERVALMATRIX_CONST_INTERVALVECTOR_REF, "x"_a) - .def(py::init&,double>&>(), + .def(py::init&>(), INTERVALMATRIX_INTERVALMATRIX_CONST_MATRIXBASEBLOCK_QT_REF, "x"_a) - .def(py::init&,Interval>&>(), + .def(py::init&>(), INTERVALMATRIX_INTERVALMATRIX_CONST_MATRIXBASEBLOCK_QT_REF, "x"_a) diff --git a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h index e7890645..d0afc06a 100644 --- a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h +++ b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h @@ -29,111 +29,111 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) pyclass .def("volume", &S::volume, - DOUBLE_INTERVALMATRIXBASE_SV_VOLUME_CONST) + DOUBLE_INTERVALMATRIXBASE_SVROWSCOLS_VOLUME_CONST) .def("is_empty", &S::is_empty, - BOOL_INTERVALMATRIXBASE_SV_IS_EMPTY_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_EMPTY_CONST) .def("set_empty", &S::set_empty, - VOID_INTERVALMATRIXBASE_SV_SET_EMPTY) + VOID_INTERVALMATRIXBASE_SVROWSCOLS_SET_EMPTY) .def("lb", &S::lb, - V_INTERVALMATRIXBASE_SV_LB_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_LB_CONST) .def("ub", &S::ub, - V_INTERVALMATRIXBASE_SV_UB_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_UB_CONST) .def("mid", &S::mid, - V_INTERVALMATRIXBASE_SV_MID_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_MID_CONST) .def("rand", &S::rand, - V_INTERVALMATRIXBASE_SV_RAND_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_RAND_CONST) .def("rad", &S::rad, - V_INTERVALMATRIXBASE_SV_RAD_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_RAD_CONST) .def("diam", &S::diam, - V_INTERVALMATRIXBASE_SV_DIAM_CONST) + V_INTERVALMATRIXBASE_SVROWSCOLS_DIAM_CONST) .def("min_diam", &S::min_diam, - DOUBLE_INTERVALMATRIXBASE_SV_MIN_DIAM_CONST) + DOUBLE_INTERVALMATRIXBASE_SVROWSCOLS_MIN_DIAM_CONST) .def("max_diam", &S::max_diam, - DOUBLE_INTERVALMATRIXBASE_SV_MAX_DIAM_CONST) + DOUBLE_INTERVALMATRIXBASE_SVROWSCOLS_MAX_DIAM_CONST) .def("min_diam_index", [](const S& x) { return matlab::output_index(x.min_diam_index()); }, - SIZET_INTERVALMATRIXBASE_SV_MIN_DIAM_INDEX_CONST) + SIZET_INTERVALMATRIXBASE_SVROWSCOLS_MIN_DIAM_INDEX_CONST) .def("max_diam_index", [](const S& x) { return matlab::output_index(x.max_diam_index()); }, - SIZET_INTERVALMATRIXBASE_SV_MAX_DIAM_INDEX_CONST) + SIZET_INTERVALMATRIXBASE_SVROWSCOLS_MAX_DIAM_INDEX_CONST) .def("extr_diam_index", [](const S& x, bool min) { return matlab::output_index(x.extr_diam_index(min)); }, - SIZET_INTERVALMATRIXBASE_SV_EXTR_DIAM_INDEX_BOOL_CONST, + SIZET_INTERVALMATRIXBASE_SVROWSCOLS_EXTR_DIAM_INDEX_BOOL_CONST, "min"_a) .def("__contains__", &S::contains, - BOOL_INTERVALMATRIXBASE_SV_CONTAINS_CONST_V_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_CONTAINS_CONST_V_REF_CONST) .def("contains", &S::contains, - BOOL_INTERVALMATRIXBASE_SV_CONTAINS_CONST_V_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_CONTAINS_CONST_V_REF_CONST) .def("interior_contains", &S::interior_contains, - BOOL_INTERVALMATRIXBASE_SV_INTERIOR_CONTAINS_CONST_V_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_INTERIOR_CONTAINS_CONST_V_REF_CONST) .def("is_unbounded", &S::is_unbounded, - BOOL_INTERVALMATRIXBASE_SV_IS_UNBOUNDED_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_UNBOUNDED_CONST) .def("is_degenerated", &S::is_degenerated, - BOOL_INTERVALMATRIXBASE_SV_IS_DEGENERATED_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_DEGENERATED_CONST) .def("is_flat", &S::is_flat, - BOOL_INTERVALMATRIXBASE_SV_IS_FLAT_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_FLAT_CONST) .def("intersects", &S::intersects, - BOOL_INTERVALMATRIXBASE_SV_INTERSECTS_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_INTERSECTS_CONST_S_REF_CONST) .def("is_disjoint", &S::is_disjoint, - BOOL_INTERVALMATRIXBASE_SV_IS_DISJOINT_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_DISJOINT_CONST_S_REF_CONST) .def("overlaps", &S::overlaps, - BOOL_INTERVALMATRIXBASE_SV_OVERLAPS_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_OVERLAPS_CONST_S_REF_CONST) .def("is_subset", &S::is_subset, - BOOL_INTERVALMATRIXBASE_SV_IS_SUBSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_SUBSET_CONST_S_REF_CONST) .def("is_strict_subset", &S::is_strict_subset, - BOOL_INTERVALMATRIXBASE_SV_IS_STRICT_SUBSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_STRICT_SUBSET_CONST_S_REF_CONST) .def("is_interior_subset", &S::is_interior_subset, - BOOL_INTERVALMATRIXBASE_SV_IS_INTERIOR_SUBSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_INTERIOR_SUBSET_CONST_S_REF_CONST) .def("is_strict_interior_subset", &S::is_strict_interior_subset, - BOOL_INTERVALMATRIXBASE_SV_IS_STRICT_INTERIOR_SUBSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_STRICT_INTERIOR_SUBSET_CONST_S_REF_CONST) .def("is_superset", &S::is_superset, - BOOL_INTERVALMATRIXBASE_SV_IS_SUPERSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_SUPERSET_CONST_S_REF_CONST) .def("is_strict_superset", &S::is_strict_superset, - BOOL_INTERVALMATRIXBASE_SV_IS_STRICT_SUPERSET_CONST_S_REF_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_STRICT_SUPERSET_CONST_S_REF_CONST) .def("is_bisectable", &S::is_bisectable, - BOOL_INTERVALMATRIXBASE_SV_IS_BISECTABLE_CONST) + BOOL_INTERVALMATRIXBASE_SVROWSCOLS_IS_BISECTABLE_CONST) .def("inflate", (S&(S::*)(double))&S::inflate, - S_REF_INTERVALMATRIXBASE_SV_INFLATE_DOUBLE, + S_REF_INTERVALMATRIXBASE_SVROWSCOLS_INFLATE_DOUBLE, "r"_a) .def("inflate", (S&(S::*)(const V&))&S::inflate, - S_REF_INTERVALMATRIXBASE_SV_INFLATE_CONST_V_REF, + S_REF_INTERVALMATRIXBASE_SVROWSCOLS_INFLATE_CONST_V_REF, "r"_a) .def("bisect", [](const S& x, size_t_type i, double ratio) @@ -141,27 +141,27 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) matlab::test_integer(i); return x.bisect(matlab::input_index(i),ratio); }, - PAIR_SS_INTERVALMATRIXBASE_SV_BISECT_SIZET_FLOAT_CONST, + PAIR_SS_INTERVALMATRIXBASE_SVROWSCOLS_BISECT_SIZET_FLOAT_CONST, "i"_a, "ratio"_a = 0.49) .def("bisect_largest", &S::bisect_largest, - PAIR_SS_INTERVALMATRIXBASE_SV_BISECT_LARGEST_FLOAT_CONST, + PAIR_SS_INTERVALMATRIXBASE_SVROWSCOLS_BISECT_LARGEST_FLOAT_CONST, "ratio"_a = 0.49) .def(py::self &= py::self, - S_REF_INTERVALMATRIXBASE_SV_OPERATORANDEQ_CONST_S_REF + S_REF_INTERVALMATRIXBASE_SVROWSCOLS_OPERATORANDEQ_CONST_S_REF "x"_a) .def(py::self |= py::self, - S_REF_INTERVALMATRIXBASE_SV_OPERATOROREQ_CONST_S_REF + S_REF_INTERVALMATRIXBASE_SVROWSCOLS_OPERATOROREQ_CONST_S_REF "x"_a) .def(py::self & py::self, - S_INTERVALMATRIXBASE_SV_OPERATORAND_CONST_S_REF_CONST + S_INTERVALMATRIXBASE_SVROWSCOLS_OPERATORAND_CONST_S_REF_CONST "x"_a) .def(py::self | py::self, - S_INTERVALMATRIXBASE_SV_OPERATOROR_CONST_S_REF_CONST, + S_INTERVALMATRIXBASE_SVROWSCOLS_OPERATOROR_CONST_S_REF_CONST, "x"_a) ; diff --git a/python/src/core/matrices/codac2_py_Matrix.cpp b/python/src/core/matrices/codac2_py_Matrix.cpp index e4664f58..bc38b11e 100644 --- a/python/src/core/matrices/codac2_py_Matrix.cpp +++ b/python/src/core/matrices/codac2_py_Matrix.cpp @@ -58,7 +58,7 @@ py::class_ export_Matrix(py::module& m) MATRIX_MATRIX_CONST_VECTOR_REF, "x"_a) - .def(py::init&,double>&>(), + .def(py::init&>(), MATRIX_MATRIX_CONST_MATRIXBASEBLOCK_QDOUBLE_REF, "x"_a) diff --git a/python/src/core/matrices/codac2_py_MatrixBase.h b/python/src/core/matrices/codac2_py_MatrixBase.h index eeacc5d4..f6d182ef 100644 --- a/python/src/core/matrices/codac2_py_MatrixBase.h +++ b/python/src/core/matrices/codac2_py_MatrixBase.h @@ -33,37 +33,37 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) { return x.size(); }, - SIZET_MATRIXBASE_ST_SIZE_CONST) + SIZET_MATRIXBASE_STROWSCOLS_SIZE_CONST) .def("size", [](const S& x) { return x.size(); }, - SIZET_MATRIXBASE_ST_SIZE_CONST) + SIZET_MATRIXBASE_STROWSCOLS_SIZE_CONST) .def("nb_rows", [](const S& x) { return x.nb_rows(); }, - SIZET_MATRIXBASE_ST_NB_ROWS_CONST) + SIZET_MATRIXBASE_STROWSCOLS_NB_ROWS_CONST) .def("nb_cols", [](const S& x) { return x.nb_cols(); }, - SIZET_MATRIXBASE_ST_NB_COLS_CONST) + SIZET_MATRIXBASE_STROWSCOLS_NB_COLS_CONST) .def("min_coeff", [](const S& x) { return x.min_coeff(); }, - T_MATRIXBASE_ST_MIN_COEFF_CONST) + T_MATRIXBASE_STROWSCOLS_MIN_COEFF_CONST) .def("max_coeff", [](const S& x) { return x.max_coeff(); }, - T_MATRIXBASE_ST_MAX_COEFF_CONST) + T_MATRIXBASE_STROWSCOLS_MAX_COEFF_CONST) ; @@ -75,7 +75,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) { return x.is_squared(); }, - BOOL_MATRIXBASE_ST_IS_SQUARED_CONST) + BOOL_MATRIXBASE_STROWSCOLS_IS_SQUARED_CONST) .def("__getitem__", [](const S& x, const py::tuple& ij) -> const T& { @@ -87,7 +87,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) return x(matlab::input_index(i), matlab::input_index(j)); }, py::return_value_policy::reference_internal, - CONST_T_REF_MATRIXBASE_ST_OPERATORCALL_SIZET_SIZET_CONST) + CONST_T_REF_MATRIXBASE_STROWSCOLS_OPERATORCALL_SIZET_SIZET_CONST) .def("__setitem__", [](S& x, const py::tuple& ij, const T& a) { @@ -99,7 +99,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) x(matlab::input_index(i), matlab::input_index(j)) = a; }, - T_REF_MATRIXBASE_ST_OPERATORCALL_SIZET_SIZET) + T_REF_MATRIXBASE_STROWSCOLS_OPERATORCALL_SIZET_SIZET) ; } @@ -110,14 +110,14 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) { x.init(a); }, - VOID_MATRIXBASE_ST_INIT_CONST_T_REF, + VOID_MATRIXBASE_STROWSCOLS_INIT_CONST_T_REF, "x"_a) .def("init", [](S& x, const S& a) { x.init(a); }, - VOID_MATRIXBASE_ST_INIT_CONST_S_REF, + VOID_MATRIXBASE_STROWSCOLS_INIT_CONST_S_REF, "x"_a) .def("__repr__", [](const S& x) @@ -126,7 +126,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) s << x; return string(s.str()); }, - OSTREAM_REF_OPERATOROUT_OSTREAM_REF_CONST_MATRIXBASE_ST_REF) + OSTREAM_REF_OPERATOROUT_OSTREAM_REF_CONST_MATRIXBASE_STROWSCOLS_REF) ; if constexpr(!VECTOR_INHERITANCE) @@ -136,44 +136,44 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) pyclass - .def("block", [](S& x, size_t_type i, size_t_type j, size_t_type p, size_t_type q) -> MatrixBaseBlock&,T> + .def("block", [](S& x, size_t_type i, size_t_type j, size_t_type p, size_t_type q) -> MatrixBaseBlock { matlab::test_integer(i,j); matlab::test_integer(p,q); return x.block(matlab::input_index(i),matlab::input_index(j),matlab::input_index(p),matlab::input_index(q)); }, py::keep_alive<0,1>(), - MATRIXBASEBLOCK_EIGENMATRIX_T_REFT_MATRIXBASE_ST_BLOCK_SIZET_SIZET_SIZET_SIZET) + MATRIXBASEBLOCK_EIGENTYPE_REFT_MATRIXBASE_STROWSCOLS_BLOCK_SIZET_SIZET_SIZET_SIZET) - .def("col", [](S& x, size_t_type i) -> MatrixBaseBlock&,T> + .def("col", [](S& x, size_t_type i) -> MatrixBaseBlock { matlab::test_integer(i); return x.col(matlab::input_index(i)); }, py::keep_alive<0,1>(), - MATRIXBASEBLOCK_EIGENMATRIX_T_REFT_MATRIXBASE_ST_COL_SIZET) + MATRIXBASEBLOCK_EIGENTYPE_REFT_MATRIXBASE_STROWSCOLS_COL_SIZET) - .def("row", [](S& x, size_t_type i) -> MatrixBaseBlock&,T> + .def("row", [](S& x, size_t_type i) -> MatrixBaseBlock { matlab::test_integer(i); return x.row(matlab::input_index(i)); }, py::keep_alive<0,1>(), - MATRIXBASEBLOCK_EIGENMATRIX_T_REFT_MATRIXBASE_ST_ROW_SIZET) + MATRIXBASEBLOCK_EIGENTYPE_REFT_MATRIXBASE_STROWSCOLS_ROW_SIZET) .def("__call__", [](S& x, size_t_type i, size_t_type j) -> T& { matlab::test_integer(i,j); return x(matlab::input_index(i),matlab::input_index(j)); }, py::return_value_policy::reference_internal, - T_REF_MATRIXBASE_ST_OPERATORCALL_SIZET_SIZET) + T_REF_MATRIXBASE_STROWSCOLS_OPERATORCALL_SIZET_SIZET) .def("resize", [](S& x, size_t_type nb_rows, size_t_type nb_cols) { matlab::test_integer(nb_rows, nb_cols); x.resize(nb_rows, nb_cols); }, - VOID_MATRIXBASE_ST_RESIZE_SIZET_SIZET, + VOID_MATRIXBASE_STROWSCOLS_RESIZE_SIZET_SIZET, "nb_rows"_a, "nb_cols"_a) .def_static("zeros", [](size_t_type r, size_t_type c) @@ -181,7 +181,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) matlab::test_integer(r,c); return S::zeros(r,c); }, - STATIC_S_MATRIXBASE_ST_ZEROS_SIZET_SIZET, + STATIC_S_MATRIXBASE_STROWSCOLS_ZEROS_SIZET_SIZET, "r"_a, "c"_a) .def_static("ones", [](size_t_type r, size_t_type c) @@ -189,7 +189,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) matlab::test_integer(r,c); return S::ones(r,c); }, - STATIC_S_MATRIXBASE_ST_ONES_SIZET_SIZET, + STATIC_S_MATRIXBASE_STROWSCOLS_ONES_SIZET_SIZET, "r"_a, "c"_a) .def_static("eye", [](size_t_type r, size_t_type c) @@ -197,7 +197,7 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) matlab::test_integer(r,c); return S::ones(r,c); }, - STATIC_S_MATRIXBASE_ST_EYE_SIZET_SIZET, + STATIC_S_MATRIXBASE_STROWSCOLS_EYE_SIZET_SIZET, "r"_a, "c"_a) ; @@ -205,5 +205,5 @@ void export_MatrixBase(py::module& m, py::class_& pyclass) //S abs(const MatrixBase& x) m.def("abs", [](const S& x) { return abs(x); }, - S_ABS_CONST_MATRIXBASE_ST_REF); + S_ABS_CONST_MATRIXBASE_STROWSCOLS_REF); } \ No newline at end of file diff --git a/python/src/core/matrices/codac2_py_MatrixBaseBlock.h b/python/src/core/matrices/codac2_py_MatrixBaseBlock.h index 6e1e98dd..14d1a562 100644 --- a/python/src/core/matrices/codac2_py_MatrixBaseBlock.h +++ b/python/src/core/matrices/codac2_py_MatrixBaseBlock.h @@ -22,32 +22,32 @@ namespace py = pybind11; using namespace pybind11::literals; template -py::class_&,T>> export_MatrixBaseBlock(py::module& m, const std::string& name) +py::class_> export_MatrixBaseBlock(py::module& m, const std::string& name) { - py::class_&,T>> exported_mbb_class(m, name.c_str(), MATRIXBASEBLOCK_MAIN); + py::class_> exported_mbb_class(m, name.c_str(), MATRIXBASEBLOCK_MAIN); exported_mbb_class - .def("init", [](MatrixBaseBlock&,T>& x, const S& a) + .def("init", [](MatrixBaseBlock& x, const S& a) { return x = a; }, VOID_MATRIXBASEBLOCK_QT_INIT_CONST_S__REF, "x"_a) - .def("nb_rows", &MatrixBaseBlock&,T>::nb_rows, + .def("nb_rows", &MatrixBaseBlock::nb_rows, SIZET_MATRIXBASEBLOCK_QT_NB_ROWS_CONST) - .def("nb_cols", &MatrixBaseBlock&,T>::nb_cols, + .def("nb_cols", &MatrixBaseBlock::nb_cols, SIZET_MATRIXBASEBLOCK_QT_NB_COLS_CONST) - .def("eval", &MatrixBaseBlock&,T>::eval, + .def("eval", &MatrixBaseBlock::eval, AUTO_MATRIXBASEBLOCK_QT_EVAL_CONST) .def(py::self == py::self) .def(py::self != py::self) - .def("__repr__", [](const MatrixBaseBlock&,T>& x) + .def("__repr__", [](const MatrixBaseBlock& x) { std::ostringstream s; s << x; diff --git a/python/src/core/matrices/codac2_py_arithmetic_add.cpp b/python/src/core/matrices/codac2_py_arithmetic_add.cpp index 5c5b8fbd..2adb8232 100644 --- a/python/src/core/matrices/codac2_py_arithmetic_add.cpp +++ b/python/src/core/matrices/codac2_py_arithmetic_add.cpp @@ -18,8 +18,8 @@ using namespace codac2; namespace py = pybind11; using namespace pybind11::literals; -using B = MatrixBaseBlock&,double>; -using IB = MatrixBaseBlock&,Interval>; +using B = MatrixBaseBlock; +using IB = MatrixBaseBlock; void export_arithmetic_add(py::module& m, py::class_& py_V, py::class_& py_IV, diff --git a/python/src/core/matrices/codac2_py_arithmetic_div.cpp b/python/src/core/matrices/codac2_py_arithmetic_div.cpp index eb318df7..ee430951 100644 --- a/python/src/core/matrices/codac2_py_arithmetic_div.cpp +++ b/python/src/core/matrices/codac2_py_arithmetic_div.cpp @@ -18,8 +18,8 @@ using namespace codac2; namespace py = pybind11; using namespace pybind11::literals; -using B = MatrixBaseBlock&,double>; -using IB = MatrixBaseBlock&,Interval>; +using B = MatrixBaseBlock; +using IB = MatrixBaseBlock; void export_arithmetic_div(py::module& m, py::class_& py_V, py::class_& py_IV, diff --git a/python/src/core/matrices/codac2_py_arithmetic_mul.cpp b/python/src/core/matrices/codac2_py_arithmetic_mul.cpp index 94713df0..adfeaf1d 100644 --- a/python/src/core/matrices/codac2_py_arithmetic_mul.cpp +++ b/python/src/core/matrices/codac2_py_arithmetic_mul.cpp @@ -18,8 +18,8 @@ using namespace codac2; namespace py = pybind11; using namespace pybind11::literals; -using B = MatrixBaseBlock&,double>; -using IB = MatrixBaseBlock&,Interval>; +using B = MatrixBaseBlock; +using IB = MatrixBaseBlock; void export_arithmetic_mul(py::module& m, py::class_& py_V, py::class_& py_IV, diff --git a/python/src/core/matrices/codac2_py_arithmetic_sub.cpp b/python/src/core/matrices/codac2_py_arithmetic_sub.cpp index 715fb06e..eaca2259 100644 --- a/python/src/core/matrices/codac2_py_arithmetic_sub.cpp +++ b/python/src/core/matrices/codac2_py_arithmetic_sub.cpp @@ -18,8 +18,8 @@ using namespace codac2; namespace py = pybind11; using namespace pybind11::literals; -using B = MatrixBaseBlock&,double>; -using IB = MatrixBaseBlock&,Interval>; +using B = MatrixBaseBlock; +using IB = MatrixBaseBlock; void export_arithmetic_sub(py::module& m, py::class_& py_V, py::class_& py_IV, diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index db305b75..a3258276 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -100,6 +100,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_Matrix.cpp ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_Matrix.h ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_MatrixBase.h + ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_MatrixBase_fwd.h ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_MatrixBaseBlock.h ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_Vector.cpp ${CMAKE_CURRENT_SOURCE_DIR}/matrices/codac2_Vector.h diff --git a/src/core/domains/interval/codac2_IntervalMatrixBase.h b/src/core/domains/interval/codac2_IntervalMatrixBase.h index 2d47d717..7361c34a 100644 --- a/src/core/domains/interval/codac2_IntervalMatrixBase.h +++ b/src/core/domains/interval/codac2_IntervalMatrixBase.h @@ -23,21 +23,21 @@ namespace codac2 { class IntervalMatrix; - template - class IntervalMatrixBase : virtual public MatrixBase, public DomainInterface + template + class IntervalMatrixBase : virtual public MatrixBase, public DomainInterface { public: explicit IntervalMatrixBase(size_t r, size_t c) - : MatrixBase(r,c) + : MatrixBase(r,c) { } explicit IntervalMatrixBase(size_t r, size_t c, const Interval& x) - : MatrixBase(r,c,x) + : MatrixBase(r,c,x) { } explicit IntervalMatrixBase(size_t r, size_t c, const double bounds[][2]) - : MatrixBase(r,c) + : MatrixBase(r,c) { size_t k = 0; for(size_t i = 0 ; i < this->nb_rows() ; i++) @@ -50,12 +50,12 @@ namespace codac2 } IntervalMatrixBase(std::initializer_list> l) - : MatrixBase(l) + : MatrixBase(l) { } template IntervalMatrixBase(const Eigen::MatrixBase& x) - : MatrixBase(x) + : MatrixBase(x) { } double volume() const @@ -478,12 +478,12 @@ namespace codac2 return y |= x; } - friend bool operator==(const IntervalMatrixBase& x1, const IntervalMatrixBase& x2) + friend bool operator==(const IntervalMatrixBase& x1, const IntervalMatrixBase& x2) { if(x1.is_empty() || x2.is_empty()) return x1.is_empty() && x2.is_empty() && x1.size() == x2.size(); - return (MatrixBase)x1 == (MatrixBase)x2; + return (MatrixBase)x1 == (MatrixBase)x2; } std::pair bisect(size_t i, float ratio = 0.49) const diff --git a/src/core/domains/interval/codac2_IntervalVector.cpp b/src/core/domains/interval/codac2_IntervalVector.cpp index 8d1cef0b..589d20c8 100644 --- a/src/core/domains/interval/codac2_IntervalVector.cpp +++ b/src/core/domains/interval/codac2_IntervalVector.cpp @@ -21,30 +21,30 @@ namespace codac2 } IntervalVector::IntervalVector(size_t n, const Interval& x) - : MatrixBase(n,1,x), - IntervalMatrixBase(n,1), + : MatrixBase(n,1,x), + IntervalMatrixBase(n,1), VectorBase(n) { assert_release(n >= 0); } IntervalVector::IntervalVector(size_t n, const double bounds[][2]) - : MatrixBase(n,1), - IntervalMatrixBase(n,1,bounds), + : MatrixBase(n,1), + IntervalMatrixBase(n,1,bounds), VectorBase(n) { assert_release(n >= 0); } IntervalVector::IntervalVector(const Vector& x) - : MatrixBase(x._e.template cast()), - IntervalMatrixBase(x.size(),1), + : MatrixBase(x._e.template cast()), + IntervalMatrixBase(x.size(),1), VectorBase(x.size()) { } IntervalVector::IntervalVector(const Vector& lb, const Vector& ub) - : MatrixBase(lb._e.template cast()), - IntervalMatrixBase(lb.size(),1), + : MatrixBase(lb._e.template cast()), + IntervalMatrixBase(lb.size(),1), VectorBase(lb.size()) { assert_release(lb.size() == ub.size()); @@ -52,25 +52,25 @@ namespace codac2 } IntervalVector::IntervalVector(initializer_list l) - : MatrixBase(l.size(),1), - IntervalMatrixBase(l.size(),1), + : MatrixBase(l.size(),1), + IntervalMatrixBase(l.size(),1), VectorBase(l) { assert_release(!std::empty(l)); } - IntervalVector::IntervalVector(const MatrixBase& x) + IntervalVector::IntervalVector(const MatrixBase& x) : IntervalVector(x._e.template cast()) { } - IntervalVector::IntervalVector(const MatrixBase& x) + IntervalVector::IntervalVector(const MatrixBase& x) : IntervalVector(x._e) { } bool operator==(const IntervalVector& x1, const IntervalVector& x2) { // ^ This overload allows automatic cast for Vector == IntervalVector comparisons - return (IntervalMatrixBase)x1 == (IntervalMatrixBase)x2; + return (IntervalMatrixBase)x1 == (IntervalMatrixBase)x2; } list IntervalVector::complementary() const diff --git a/src/core/domains/interval/codac2_IntervalVector.h b/src/core/domains/interval/codac2_IntervalVector.h index ae336a74..376331ad 100644 --- a/src/core/domains/interval/codac2_IntervalVector.h +++ b/src/core/domains/interval/codac2_IntervalVector.h @@ -23,7 +23,7 @@ namespace codac2 { - class IntervalVector : public IntervalMatrixBase, public VectorBase + class IntervalVector : public IntervalMatrixBase, public VectorBase { public: @@ -39,14 +39,14 @@ namespace codac2 IntervalVector(std::initializer_list l); - IntervalVector(const MatrixBase& x); + IntervalVector(const MatrixBase& x); - IntervalVector(const MatrixBase& x); + IntervalVector(const MatrixBase& x); template IntervalVector(const Eigen::MatrixBase& x) - : MatrixBase(x.template cast()), - IntervalMatrixBase(x.template cast()), + : MatrixBase(x.template cast()), + IntervalMatrixBase(x.template cast()), VectorBase(x.template cast()) { assert_release(x.cols() == 1); diff --git a/src/core/matrices/codac2_MatrixBase.h b/src/core/matrices/codac2_MatrixBase.h index b719df52..3d334912 100644 --- a/src/core/matrices/codac2_MatrixBase.h +++ b/src/core/matrices/codac2_MatrixBase.h @@ -12,6 +12,7 @@ #include #include "codac2_eigen.h" #include "codac2_assert.h" +#include "codac2_MatrixBase_fwd.h" #include "codac2_MatrixBaseBlock.h" namespace codac2 @@ -22,29 +23,32 @@ namespace codac2 template struct MatrixBaseBlock; - template - using EigenMatrix = Eigen::Matrix; - - template + template class MatrixBase { public: + using EigenType = Eigen::Matrix; + explicit MatrixBase(size_t r, size_t c) - : _e(EigenMatrix(r,c)) + : _e(EigenType(r,c)) { + assert((Rows == (int)r || Rows == -1) && (Cols == (int)c || Cols == -1)); assert(r >= 0 && c >= 0); } explicit MatrixBase(size_t r, size_t c, const T& x) - : MatrixBase(r,c) + : MatrixBase(r,c) { + assert((Rows == (int)r || Rows == -1) && (Cols == (int)c || Cols == -1)); init(x); } explicit MatrixBase(size_t r, size_t c, const T values[]) - : MatrixBase(r,c) + : MatrixBase(r,c) { + assert((Rows == (int)r || Rows == -1) && (Cols == (int)c || Cols == -1)); + if(values == 0) init(T(0.)); // in case the user called MatrixBase(r,c,0) and 0 is interpreted as NULL! @@ -59,14 +63,16 @@ namespace codac2 } explicit MatrixBase(const std::vector& x) - : MatrixBase(x.size(),1,&x[0]) + : MatrixBase(x.size(),1,&x[0]) { + assert(Rows == -1 && Cols == -1); assert(!x.empty()); } MatrixBase(std::initializer_list> l) - : MatrixBase(0,0 /* will be resized thereafter */) + : MatrixBase(0,0 /* will be resized thereafter */) { + assert(Rows == -1 && Cols == -1); assert(!std::empty(l)); int cols = -1; @@ -88,8 +94,9 @@ namespace codac2 } MatrixBase(const std::vector>& l) - : MatrixBase(0,0 /* will be resized thereafter */) + : MatrixBase(0,0 /* will be resized thereafter */) { + assert(Rows == -1 && Cols == -1); assert(!std::empty(l)); int cols = -1; @@ -118,7 +125,7 @@ namespace codac2 virtual ~MatrixBase() { } - MatrixBase& operator=(const MatrixBase&) = default; + MatrixBase& operator=(const MatrixBase&) = default; size_t size() const { @@ -161,7 +168,7 @@ namespace codac2 minmax_item(max); } - friend bool operator==(const MatrixBase& x1, const MatrixBase& x2) + friend bool operator==(const MatrixBase& x1, const MatrixBase& x2) { if(x1.nb_rows() != x2.nb_rows() || x1.nb_cols() != x2.nb_cols()) return false; @@ -176,7 +183,7 @@ namespace codac2 T& operator()(size_t i, size_t j) { - return const_cast(const_cast*>(this)->operator()(i,j)); + return const_cast(const_cast*>(this)->operator()(i,j)); } const T& operator()(size_t i, size_t j) const @@ -208,36 +215,36 @@ namespace codac2 _e(i,j) = copy(i,j); } - MatrixBaseBlock&,T> block(size_t i, size_t j, size_t p, size_t q) + MatrixBaseBlock block(size_t i, size_t j, size_t p, size_t q) { assert_release(i >= 0 && p > 0 && i+p <= nb_rows()); assert_release(j >= 0 && q > 0 && j+q <= nb_cols()); return { _e,i,j,p,q }; } - MatrixBaseBlock&,T> block(size_t i, size_t j, size_t p, size_t q) const + MatrixBaseBlock block(size_t i, size_t j, size_t p, size_t q) const { assert_release(i >= 0 && p > 0 && i+p <= nb_rows()); assert_release(j >= 0 && q > 0 && j+q <= nb_cols()); return { _e,i,j,p,q }; } - MatrixBaseBlock&,T> col(size_t i) + MatrixBaseBlock col(size_t i) { return block(0,i,nb_rows(),1); } - MatrixBaseBlock&,T> col(size_t i) const + MatrixBaseBlock col(size_t i) const { return block(0,i,nb_rows(),1); } - MatrixBaseBlock&,T> row(size_t i) + MatrixBaseBlock row(size_t i) { return block(i,0,1,nb_cols()); } - MatrixBaseBlock&,T> row(size_t i) const + MatrixBaseBlock row(size_t i) const { return block(i,0,1,nb_cols()); } @@ -255,43 +262,43 @@ namespace codac2 static S zeros(size_t r, size_t c) { assert_release(r >= 0 && c >= 0); - return EigenMatrix::Zero(r,c); + return EigenType::Zero(r,c); } static S ones(size_t r, size_t c) { assert_release(r >= 0 && c >= 0); - return EigenMatrix::Ones(r,c); + return EigenType::Ones(r,c); } static S eye(size_t r, size_t c) { assert_release(r >= 0 && c >= 0); - return EigenMatrix::Identity(r,c); + return EigenType::Identity(r,c); } - template - friend std::ostream& operator<<(std::ostream& os, const MatrixBase& x); + template + friend std::ostream& operator<<(std::ostream& os, const MatrixBase& x); - template - friend S_ abs(const MatrixBase& x); + template + friend S_ abs(const MatrixBase& x); - operator EigenMatrix() + operator EigenType() { - return const_cast&>(const_cast*>(this)->operator EigenMatrix()); + return const_cast(const_cast*>(this)->operator EigenType()); } - operator EigenMatrix() const + operator EigenType() const { return _e; } - using iterator = typename EigenMatrix::iterator; - using const_iterator = typename EigenMatrix::const_iterator; + using iterator = typename EigenType::iterator; + using const_iterator = typename EigenType::const_iterator; iterator begin() { - return const_cast(const_cast*>(this)->begin()); + return const_cast(const_cast*>(this)->begin()); } const_iterator begin() const @@ -306,14 +313,14 @@ namespace codac2 iterator end() { - return const_cast(const_cast*>(this)->end()); + return const_cast(const_cast*>(this)->end()); } - EigenMatrix _e; + EigenType _e; }; - template - S abs(const MatrixBase& x) + template + S abs(const MatrixBase& x) { S a(x); @@ -328,8 +335,8 @@ namespace codac2 return a; } - template - std::ostream& operator<<(std::ostream& os, const MatrixBase& x) + template + std::ostream& operator<<(std::ostream& os, const MatrixBase& x) { os << "("; for(size_t i = 0 ; i < x.nb_rows() ; i++) @@ -344,8 +351,8 @@ namespace codac2 return os; } - template - const auto& eigen(const MatrixBase& x) + template + const auto& eigen(const MatrixBase& x) { return x._e; } diff --git a/src/core/matrices/codac2_MatrixBaseBlock.h b/src/core/matrices/codac2_MatrixBaseBlock.h index c1a09b8b..ad8ada14 100644 --- a/src/core/matrices/codac2_MatrixBaseBlock.h +++ b/src/core/matrices/codac2_MatrixBaseBlock.h @@ -12,13 +12,11 @@ #include #include "codac2_eigen.h" #include "codac2_assert.h" +#include "codac2_MatrixBase_fwd.h" #include "codac2_MatrixBase.h" namespace codac2 { - template - class MatrixBase; - template struct MatrixBaseBlock { @@ -42,8 +40,8 @@ namespace codac2 return _q; } - template - void operator=(const MatrixBase& x) + template + void operator=(const MatrixBase& x) { assert_release(x.nb_rows() == _p && x.nb_cols() == _q); _m.block(_i,_j,_p,_q) = x._e; diff --git a/src/core/matrices/codac2_MatrixBase_fwd.h b/src/core/matrices/codac2_MatrixBase_fwd.h new file mode 100644 index 00000000..44fe5ee0 --- /dev/null +++ b/src/core/matrices/codac2_MatrixBase_fwd.h @@ -0,0 +1,16 @@ +/** + * \file codac2_MatrixBase_fwd.h + * ---------------------------------------------------------------------------- + * \date 2024 + * \author Simon Rohou + * \copyright Copyright 2024 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#pragma once + +namespace codac2 +{ + template + class MatrixBase; +} \ No newline at end of file diff --git a/src/core/matrices/codac2_Vector.cpp b/src/core/matrices/codac2_Vector.cpp index 324c7a3d..24768680 100644 --- a/src/core/matrices/codac2_Vector.cpp +++ b/src/core/matrices/codac2_Vector.cpp @@ -21,27 +21,27 @@ namespace codac2 } Vector::Vector(size_t n, double x) - : MatrixBase(n,1,x), + : MatrixBase(n,1,x), VectorBase(n) { assert_release(n >= 0); } Vector::Vector(std::initializer_list l) - : MatrixBase(l.size(),1), + : MatrixBase(l.size(),1), VectorBase(l) { assert_release(!std::empty(l)); } Vector::Vector(const std::vector& l) - : MatrixBase(l.size(),1), + : MatrixBase(l.size(),1), VectorBase(l) { assert_release(!std::empty(l)); } - Vector::Vector(const MatrixBase& x) + Vector::Vector(const MatrixBase& x) : Vector(x._e) { } diff --git a/src/core/matrices/codac2_Vector.h b/src/core/matrices/codac2_Vector.h index 2e59adf4..a75fa6c1 100644 --- a/src/core/matrices/codac2_Vector.h +++ b/src/core/matrices/codac2_Vector.h @@ -29,11 +29,11 @@ namespace codac2 Vector(const std::vector& l); - Vector(const MatrixBase& x); + Vector(const MatrixBase& x); template Vector(const Eigen::MatrixBase& x) - : MatrixBase(x), + : MatrixBase(x), VectorBase(x) { } diff --git a/src/core/matrices/codac2_VectorBase.h b/src/core/matrices/codac2_VectorBase.h index 7340421c..2ee4bcff 100644 --- a/src/core/matrices/codac2_VectorBase.h +++ b/src/core/matrices/codac2_VectorBase.h @@ -14,18 +14,18 @@ namespace codac2 { template - class VectorBase : virtual public MatrixBase + class VectorBase : virtual public MatrixBase { public: explicit VectorBase(size_t n) - : MatrixBase(n,1) + : MatrixBase(n,1) { assert_release(n >= 0); } VectorBase(std::initializer_list l) - : MatrixBase(l.size(),1) + : MatrixBase(l.size(),1) { assert(!std::empty(l)); size_t i = 0; @@ -34,7 +34,7 @@ namespace codac2 } VectorBase(const std::vector& l) - : MatrixBase(l.size(),1) + : MatrixBase(l.size(),1) { assert(!std::empty(l)); size_t i = 0; @@ -44,7 +44,7 @@ namespace codac2 template VectorBase(const Eigen::MatrixBase& x) - : MatrixBase(x) + : MatrixBase(x) { } bool is_squared() const = delete; @@ -70,7 +70,7 @@ namespace codac2 void resize(size_t n) { assert_release(n >= 0); - MatrixBase::resize(n,1); + MatrixBase::resize(n,1); } void put(size_t start_id, const S& x) @@ -96,13 +96,13 @@ namespace codac2 static S zeros(size_t n) { assert_release(n >= 0); - return EigenMatrix::Zero(n,1); + return S::EigenType::Zero(n,1); } static S ones(size_t n) { assert_release(n >= 0); - return EigenMatrix::Ones(n,1); + return S::EigenType::Ones(n,1); } }; diff --git a/src/core/tools/codac2_template_tools.h b/src/core/tools/codac2_template_tools.h index ea5dad5b..489dc5b6 100644 --- a/src/core/tools/codac2_template_tools.h +++ b/src/core/tools/codac2_template_tools.h @@ -17,13 +17,13 @@ namespace codac2 { template concept IsMatrix = (std::is_same_v - || std::is_same_v&,double>,T> - || std::is_same_v&,double>,T>); + || std::is_same_v,T> + || std::is_same_v,T>); template concept IsIntervalMatrix = (std::is_same_v - || std::is_same_v&,Interval>,T> - || std::is_same_v&,Interval>,T>); + || std::is_same_v,T> + || std::is_same_v,T>); template concept IsCtcBaseOrPtr = (std::is_base_of_v,C>