From fe28ab12a938cbdc998fce16fa293141ed5cc672 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Mon, 13 Apr 2026 10:03:41 +0200 Subject: [PATCH 01/21] [paving] minor update --- src/core/domains/paving/codac2_Paving.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/core/domains/paving/codac2_Paving.h b/src/core/domains/paving/codac2_Paving.h index 7a8c2d4b9..3bd70a2a7 100644 --- a/src/core/domains/paving/codac2_Paving.h +++ b/src/core/domains/paving/codac2_Paving.h @@ -154,10 +154,11 @@ namespace codac2 { assert_release(x.size() == this->size()); + IntervalVector x_ = IntervalVector::empty(x.size()); + if(x.is_empty()) - return IntervalVector::empty(x.size()); + return x_; - IntervalVector x_ = IntervalVector::empty(x.size()); this->tree()->visit([&] (Node_ n) { From 372c487f975c6e9a3086e0c679fea59678397b0d Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Tue, 14 Apr 2026 09:53:51 +0200 Subject: [PATCH 02/21] [src] added among_indices option for min/max_diam, bisect_largest, etc. --- .../interval/codac2_py_IntervalMatrixBase.h | 72 +++++++++++++------ ...ac2_MatrixBase_addons_IntervalMatrixBase.h | 56 +++++++++++---- .../codac2_Matrix_addons_IntervalMatrixBase.h | 7 +- 3 files changed, 97 insertions(+), 38 deletions(-) diff --git a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h index 622d22db5..a5da22274 100644 --- a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h +++ b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h @@ -70,36 +70,61 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) .def("diam", [](const S& x) { return x.diam(); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_AUTO_DIAM_CONST) - .def("min_rad", [](const S& x) { return x.min_rad(); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_RAD_CONST) + .def("min_rad", [](const S& x, const std::vector& among_indices) + { + return x.min_rad( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); + }, + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_RAD_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("max_rad", [](const S& x) { return x.max_rad(); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_RAD_CONST) + .def("max_rad", [](const S& x, const std::vector& among_indices) + { + return x.max_rad( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); + }, + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_RAD_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("min_diam", [](const S& x) { return x.min_diam(); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_DIAM_CONST) + .def("min_diam", [](const S& x, const std::vector& among_indices) + { + return x.min_diam( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); + }, + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_DIAM_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("max_diam", [](const S& x) { return x.max_diam(); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_DIAM_CONST) + .def("max_diam", [](const S& x, const std::vector& among_indices) + { + return x.max_diam( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); + }, + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_DIAM_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("min_diam_index", [](const S& x) + .def("min_diam_index", [](const S& x, const std::vector& among_indices) { - return matlab::output_index(x.min_diam_index()); + return matlab::output_index(x.min_diam_index( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MIN_DIAM_INDEX_CONST) + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MIN_DIAM_INDEX_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("max_diam_index", [](const S& x) + .def("max_diam_index", [](const S& x, const std::vector& among_indices) { - return matlab::output_index(x.max_diam_index()); + return matlab::output_index(x.max_diam_index( + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MAX_DIAM_INDEX_CONST) + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MAX_DIAM_INDEX_CONST_VECTOR_INDEX_REF_CONST, + "among_indices"_a=std::vector()) - .def("extr_diam_index", [](const S& x, bool min) + .def("extr_diam_index", [](const S& x, bool min, const std::vector& among_indices) { - return matlab::output_index(x.extr_diam_index(min)); + return matlab::output_index(x.extr_diam_index(min, + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, - MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_EXTR_DIAM_INDEX_BOOL_CONST, - "min"_a) + MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_EXTR_DIAM_INDEX_BOOL_CONST_VECTOR_INDEX_REF_CONST, + "min"_a, "among_indices"_a=std::vector()) .def("__contains__", [](const S& x, const V& y) { return x.contains(y); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_BOOL_CONTAINS_CONST_MATRIXBASE_OTHERDERIVED_REF_CONST) @@ -168,9 +193,14 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_INDEX_FLOAT_CONST, "i"_a, "ratio"_a = 0.49) - .def("bisect_largest", [](const S& x, double ratio = 0.49) { return x.bisect_largest(ratio); }, - MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_LARGEST_FLOAT_CONST, - "ratio"_a = 0.49) + .def("bisect_largest", + [](const S& x, double ratio, const std::vector& among_indices) + { + return x.bisect_largest(ratio, + among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); + }, + MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_LARGEST_FLOAT_CONST_VECTOR_INDEX_REF_CONST, + "ratio"_a = 0.49, "among_indices"_a=std::vector()) ; if constexpr(!FOR_MATLAB) diff --git a/src/core/matrices/eigen/MatrixBase_addons/codac2_MatrixBase_addons_IntervalMatrixBase.h b/src/core/matrices/eigen/MatrixBase_addons/codac2_MatrixBase_addons_IntervalMatrixBase.h index c894cc438..187c91da9 100644 --- a/src/core/matrices/eigen/MatrixBase_addons/codac2_MatrixBase_addons_IntervalMatrixBase.h +++ b/src/core/matrices/eigen/MatrixBase_addons/codac2_MatrixBase_addons_IntervalMatrixBase.h @@ -216,67 +216,73 @@ inline auto diam() const /** * \brief Returns the minimum radius among the interval elements. * + * \param among_indices Optional restricted set of dimension indices. * \return The smallest radius value in the matrix. */ -inline double min_rad() const +inline double min_rad(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return coeff(this->extr_diam_index(true)).rad(); + return coeff(this->extr_diam_index(true,among_indices)).rad(); } /** * \brief Returns the maximum radius among the interval elements. * + * \param among_indices Optional restricted set of dimension indices. * \return The largest radius value in the matrix. */ -inline double max_rad() const +inline double max_rad(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return coeff(this->extr_diam_index(false)).rad(); + return coeff(this->extr_diam_index(false,among_indices)).rad(); } /** * \brief Returns the minimum diameter among the interval elements. * + * \param among_indices Optional restricted set of dimension indices. * \return The smallest diameter value in the matrix. */ -inline double min_diam() const +inline double min_diam(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return coeff(this->extr_diam_index(true)).diam(); + return coeff(this->extr_diam_index(true,among_indices)).diam(); } /** * \brief Returns the maximum diameter among the interval elements. * + * \param among_indices Optional restricted set of dimension indices. * \return The largest diameter value in the matrix. */ -inline double max_diam() const +inline double max_diam(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return coeff(this->extr_diam_index(false)).diam(); + return coeff(this->extr_diam_index(false,among_indices)).diam(); } /** * \brief Returns the index of the element with the minimum diameter. * + * \param among_indices Optional restricted set of dimension indices. * \return The index of the matrix element with the smallest diameter. */ -inline Index min_diam_index() const +inline Index min_diam_index(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return this->extr_diam_index(true); + return this->extr_diam_index(true,among_indices); } /** * \brief Returns the index of the element with the maximum diameter. * + * \param among_indices Optional restricted set of dimension indices. * \return The index of the matrix element with the largest diameter. */ -inline Index max_diam_index() const +inline Index max_diam_index(const std::vector& among_indices = {}) const requires IsIntervalDomain { - return this->extr_diam_index(false); + return this->extr_diam_index(false,among_indices); } /** @@ -290,14 +296,20 @@ inline Index max_diam_index() const * - If looking for maximum diameter, unbounded intervals are considered. * * \param min If ``true``, returns the index of the element with minimum diameter; otherwise maximum diameter. + * \param among_indices Optional restricted set of dimension indices. * * \return Index of the element with the minimum or maximum diameter. * * \pre The matrix must not be empty (diameter undefined otherwise). */ -inline Index extr_diam_index(bool min) const +inline Index extr_diam_index(bool min, const std::vector& among_indices = {}) const requires IsIntervalDomain { + assert_release( + among_indices.empty() || + std::ranges::all_of(among_indices, [&](Index k){ return 0 <= k && k < this->size(); }) + ); + // This code originates from the ibex-lib // See: ibex_TemplateVector.h // Author: Gilles Chabert @@ -311,6 +323,10 @@ inline Index extr_diam_index(bool min) const for(i = 0 ; i < this->size() ; i++) { + if(!among_indices.empty() + && std::find(among_indices.begin(),among_indices.end(),i) == among_indices.end()) + continue; // avoiding this index + if(coeff(i).is_unbounded()) { unbounded = true; @@ -330,8 +346,14 @@ inline Index extr_diam_index(bool min) const if(min && selected_index == -1) { assert(unbounded); - // the selected interval is the first one. - i = 0; + + if(among_indices.empty()) + { + // the selected interval is the first one. + i = 0; + } + else + i = among_indices[0]; } // The unbounded intervals are not considered if we look for the minimal diameter @@ -343,6 +365,10 @@ inline Index extr_diam_index(bool min) const for(; i < this->size() ; i++) { + if(!among_indices.empty() + && std::find(among_indices.begin(),among_indices.end(),i) == among_indices.end()) + continue; // avoiding this index + if(coeff(i).lb() == -codac2::oo) { if(coeff(i).ub() == codac2::oo) diff --git a/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h b/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h index b9c08c129..fea1964d0 100644 --- a/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h +++ b/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h @@ -331,12 +331,15 @@ inline auto bisect(Index i, float ratio = 0.49) const * Uses ``max_diam_index()`` to find the element with the largest diameter and bisects * it using the given ratio. * + * The indices may be restricted to a set of values provided in ``among_indices``. + * * \param ratio Ratio to determine the split point within the interval (default 0.49). + * \param among_indices Optional set of indices among which the bisection will be performed. * \return A pair of matrices resulting from the bisection of the largest diameter interval. */ template requires IsIntervalDomain -inline auto bisect_largest(float ratio = 0.49) const +inline auto bisect_largest(float ratio = 0.49, const std::vector& among_indices = {}) const { - return bisect(this->max_diam_index(), ratio); + return bisect(this->max_diam_index(among_indices), ratio); } \ No newline at end of file From a1ec84e3febbddf60b62131813e874c1c0d64d3e Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Wed, 15 Apr 2026 14:37:55 +0200 Subject: [PATCH 03/21] [tubes] documentation + minor corrections --- .../domains/tube/codac2_py_SlicedTube.cpp | 27 +- .../core/domains/tube/codac2_py_TSlice.cpp | 7 +- src/core/CMakeLists.txt | 1 + src/core/domains/codac2_Scalar.h | 39 ++ src/core/domains/tube/codac2_Slice.h | 195 +++++++- src/core/domains/tube/codac2_SliceBase.h | 78 +++- src/core/domains/tube/codac2_SlicedTube.h | 422 +++++++++++++++++- src/core/domains/tube/codac2_SlicedTubeBase.h | 54 +++ src/core/domains/tube/codac2_TDomain.cpp | 37 +- src/core/domains/tube/codac2_TSlice.cpp | 10 - src/core/domains/tube/codac2_TSlice.h | 53 ++- src/core/domains/tube/codac2_TubeBase.h | 38 +- src/core/domains/tube/codac2_tube_cart_prod.h | 23 +- 13 files changed, 904 insertions(+), 80 deletions(-) create mode 100644 src/core/domains/codac2_Scalar.h diff --git a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp b/python/src/core/domains/tube/codac2_py_SlicedTube.cpp index 9182b381b..c131a5096 100644 --- a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp +++ b/python/src/core/domains/tube/codac2_py_SlicedTube.cpp @@ -171,12 +171,12 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: "x"_a) .def(py::self &= py::self, - SLICEDTUBE_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, + SLICEDTUBE_REF_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, "x"_a) // For MATLAB compatibility .def("self_inter", &SlicedTube::operator&=, - SLICEDTUBE_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, + SLICEDTUBE_REF_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, "x"_a) .def("as_function", &SlicedTube::as_function, @@ -246,6 +246,8 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, "y"_a, "v_t"_a, "v"_a, "t"_a=Interval()) + .def("mid", &SlicedTube::mid, + SAMPLEDTRAJ_TYPENAME_SCALAR_T_TYPE_SLICEDTUBE_T_MID_CONST); ; } @@ -297,27 +299,6 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: ; } - if constexpr(std::is_same_v) - { - exported_slicedtube_class - .def("mid", &SlicedTube::mid, - AUTO_SLICEDTUBE_T_MID_CONST); - } - - if constexpr(std::is_same_v) - { - exported_slicedtube_class - .def("mid", &SlicedTube::mid, - AUTO_SLICEDTUBE_T_MID_CONST); - } - - if constexpr(std::is_same_v) - { - exported_slicedtube_class - .def("mid", &SlicedTube::mid, - AUTO_SLICEDTUBE_T_MID_CONST); - } - return exported_slicedtube_class; } diff --git a/python/src/core/domains/tube/codac2_py_TSlice.cpp b/python/src/core/domains/tube/codac2_py_TSlice.cpp index 6cb11ab83..405441cb9 100644 --- a/python/src/core/domains/tube/codac2_py_TSlice.cpp +++ b/python/src/core/domains/tube/codac2_py_TSlice.cpp @@ -32,12 +32,9 @@ void export_TSlice(py::module& m) .def("slices", &TSlice::slices, CONST_MAP_CONST_SLICEDTUBEBASE_PTRSHARED_PTR_SLICEBASE_REF_TSLICE_SLICES_CONST) - .def(py::self == py::self, - BOOL_TSLICE_OPERATOREQ_CONST_TSLICE_REF_CONST, - "x"_a) + .def(py::self == py::self, "x"_a) - .def(py::self != py::self, - "x"_a) + .def(py::self != py::self, "x"_a) ; } diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 4f6a00ed6..81565e93c 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -61,6 +61,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/domains/codac2_BoolInterval.h ${CMAKE_CURRENT_SOURCE_DIR}/domains/codac2_Domain.h + ${CMAKE_CURRENT_SOURCE_DIR}/domains/codac2_Scalar.h ${CMAKE_CURRENT_SOURCE_DIR}/domains/codac2_Wrapper.h ${CMAKE_CURRENT_SOURCE_DIR}/domains/ellipsoid/codac2_Ellipsoid.cpp ${CMAKE_CURRENT_SOURCE_DIR}/domains/ellipsoid/codac2_Ellipsoid_checks.cpp diff --git a/src/core/domains/codac2_Scalar.h b/src/core/domains/codac2_Scalar.h new file mode 100644 index 000000000..ca848dd7e --- /dev/null +++ b/src/core/domains/codac2_Scalar.h @@ -0,0 +1,39 @@ +/** + * \file codac2_Scalar.h + * ---------------------------------------------------------------------------- + * \date 2026 + * \author Simon Rohou + * \copyright Copyright 2026 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#pragma once + +#include "codac2_Interval.h" +#include "codac2_Vector.h" +#include "codac2_Matrix.h" +#include "codac2_IntervalVector.h" +#include "codac2_IntervalMatrix.h" + +namespace codac2 +{ + template + struct Scalar + { }; + + template<> + struct Scalar { + using Type = double; + }; + + template + struct Scalar,OtherDerived>>::type> + { + using Type = Eigen::Matrix; + // Automatically sets: + // Scalar::Type = Vector + // Scalar::Type = Matrix + // + related possible expression templates + }; +} \ No newline at end of file diff --git a/src/core/domains/tube/codac2_Slice.h b/src/core/domains/tube/codac2_Slice.h index 71da4fae0..3fcf913a8 100644 --- a/src/core/domains/tube/codac2_Slice.h +++ b/src/core/domains/tube/codac2_Slice.h @@ -17,6 +17,23 @@ namespace codac2 { + /** + * \class Slice + * \brief Codomain of a sliced tube over one temporal slice + * + * A ``Slice`` represents the codomain of a ``SlicedTube`` over one + * temporal interval of a ``TDomain``. + * + * This object is attached to one temporal slice ``TSlice`` and stores a + * codomain of type ``T``. The type ``T`` is typically ``Interval`` or + * ``IntervalVector``, or any custom domain implemented by the user. + * + * The inheritance from ``T`` is protected so that modifications of the + * codomain remain controlled by the ``Slice`` interface. Indeed, changing the + * codomain of a slice may require propagating contractions to adjacent gates. + * + * \tparam T codomain type + */ template class Slice : public SliceBase, protected T @@ -25,10 +42,26 @@ namespace codac2 { public: + /** + * \brief Creates a slice attached to a tube over a temporal slice + * + * \param tube sliced tube owning this slice + * \param it_tslice iterator to the associated temporal slice + * \param codomain codomain associated with this slice + */ explicit Slice(const SlicedTubeBase& tube, const std::list::iterator& it_tslice, const T& codomain) : SliceBase(tube, it_tslice), T(codomain) { } + /** + * \brief Creates a slice from another one for a given tube + * + * This constructor duplicates the codomain and keeps the same temporal + * support. + * + * \param s source slice + * \param tube sliced tube owning the copied slice + */ Slice(const Slice& s, const SlicedTubeBase& tube) : SliceBase(tube, s._it_tslice), T(s.codomain()) { } @@ -40,60 +73,124 @@ namespace codac2 Slice(Slice&&) = delete; Slice& operator=(Slice&&) = delete; + /** + * \brief Returns the sliced tube owning this slice + * + * \return reference to the parent sliced tube + */ inline const SlicedTube& tube() const { return static_cast&>(_tube); } - inline virtual std::shared_ptr copy() const + /** + * \brief Duplicates this slice + * + * \return shared pointer to a copy of this slice + */ + inline std::shared_ptr copy() const override { return std::make_shared(*this, this->_tube); } + /** + * \brief Returns the codomain dimension + * + * \return size of the codomain + */ inline Index size() const { return this->T::size(); } + /** + * \brief Returns a mutable reference to the codomain + * + * \note Prefer ``set()`` when adjacency propagation is required. + * + * \return mutable reference to the codomain + */ inline T& codomain() { - return (T&)(*this); + return static_cast(*this); } + /** + * \brief Returns a constant reference to the codomain + * + * \return constant reference to the codomain + */ inline const T& codomain() const { - return (const T&)(*this); + return static_cast(*this); } + /** + * \brief Tests whether this slice is a gate + * + * A slice is considered a gate when its temporal support is degenerate. + * + * \return ``true`` if this slice is a gate, ``false`` otherwise + */ inline bool is_gate() const { return t0_tf().is_degenerated(); } + /** + * \brief Returns the previous slice + * + * \return shared pointer to the previous slice, or ``nullptr`` if none exists + */ inline std::shared_ptr> prev_slice() const { return std::static_pointer_cast>( this->SliceBase::prev_slice()); } + /** + * \brief Returns the previous slice + * + * \return shared pointer to the previous slice, or ``nullptr`` if none exists + */ inline std::shared_ptr> prev_slice() { return std::const_pointer_cast>( static_cast&>(*this).prev_slice()); } + /** + * \brief Returns the next slice + * + * \return shared pointer to the next slice, or ``nullptr`` if none exists + */ inline std::shared_ptr> next_slice() const { return std::static_pointer_cast>( this->SliceBase::next_slice()); } + /** + * \brief Returns the next slice + * + * \return shared pointer to the next slice, or ``nullptr`` if none exists + */ inline std::shared_ptr> next_slice() { return std::const_pointer_cast>( static_cast&>(*this).next_slice()); } + /** + * \brief Returns the input gate of this slice + * + * If the previous temporal element is an explicit gate, its codomain is + * returned. Otherwise, the returned value is the intersection between this + * codomain and the codomain of the previous slice. If no previous slice + * exists, the codomain of this slice is returned. + * + * \return enclosure of the input gate + */ inline T input_gate() const { if(!prev_slice()) @@ -108,6 +205,16 @@ namespace codac2 } } + /** + * \brief Returns the output gate of this slice + * + * If the next temporal element is an explicit gate, its codomain is + * returned. Otherwise, the returned value is the intersection between this + * codomain and the codomain of the next slice. If no next slice exists, + * the codomain of this slice is returned. + * + * \return enclosure of the output gate + */ inline T output_gate() const { if(!next_slice()) @@ -122,6 +229,16 @@ namespace codac2 } } + /** + * \brief Returns enclosed lower and upper bounds over a temporal interval + * + * This method returns a pair whose first component encloses the reachable + * lower bounds and whose second component encloses the reachable upper + * bounds over ``t``. + * + * \param t temporal interval + * \return pair made of enclosed lower and upper bounds + */ inline std::pair enclosed_bounds(const Interval& t) const { T x = *this; x.set_empty(); @@ -156,6 +273,15 @@ namespace codac2 return bounds; } + /** + * \brief Sets the codomain of this slice + * + * If ``propagate`` is set to ``true``, adjacent gates are updated in order + * to preserve temporal consistency. + * + * \param x new codomain + * \param propagate if set to ``true``, propagates the update to adjacent gates + */ inline void set(const T& x, bool propagate = true) { assert_release(x.size() == this->size()); @@ -164,22 +290,49 @@ namespace codac2 update_adjacent_codomains(); } + /** + * \brief Initializes this codomain to its unbounded value + * + * No propagation is performed on adjacent slices. + */ inline void init() { this->T::init(); // Nothing to propagate to adjacent codomains } + /** + * \brief Sets this codomain to the empty set + * + * Adjacent gates are updated accordingly. + */ inline void set_empty() { set_empty(true); } + /** + * \brief Compares two slices + * + * The comparison only involves the codomain of the slices. + * + * \param x slice to compare with + * \return ``true`` if both codomains are equal, ``false`` otherwise + */ inline bool operator==(const Slice& x) const { return codomain() == x.codomain(); } + /** + * \brief Returns the polygonal enclosure associated with this scalar slice + * + * The enclosure is built from the codomain of this slice, its input/output + * gates and the derivative information provided by ``v``. + * + * \param v derivative slice + * \return polygonal enclosure of this slice + */ inline ConvexPolygon polygon_slice(const Slice& v) const requires std::is_same_v { @@ -200,6 +353,14 @@ namespace codac2 v); } + /** + * \brief Returns the polygonal enclosure associated with one component + * of a vector slice + * + * \param v derivative slice + * \param i component index + * \return polygonal enclosure of the \f$i\f$-th component + */ inline ConvexPolygon polygon_slice_i(const Slice& v, Index i) const requires std::is_same_v { @@ -375,6 +536,13 @@ namespace codac2 } } + /** + * \brief Stream output for a slice + * + * \param os output stream + * \param x slice to be displayed + * \return reference to the output stream + */ friend inline std::ostream& operator<<(std::ostream& os, const Slice& x) { os << x.t0_tf() @@ -383,6 +551,11 @@ namespace codac2 return os; } + /** + * \brief Returns the unbounded value associated with this codomain type + * + * \return unbounded value of type ``T`` + */ inline T all_reals_value() const { T x = codomain(); @@ -390,6 +563,11 @@ namespace codac2 return x; } + /** + * \brief Returns the empty value associated with this codomain type + * + * \return empty value of type ``T`` + */ inline T empty_value() const { T x = codomain(); @@ -403,6 +581,11 @@ namespace codac2 template friend class SlicedTube; + /** + * \brief Sets this codomain to the empty set + * + * \param propagate if set to ``true``, propagates the update to adjacent gates + */ inline void set_empty(bool propagate) { this->T::set_empty(); @@ -410,6 +593,12 @@ namespace codac2 update_adjacent_codomains(); } + /** + * \brief Propagates codomain contractions to adjacent gates + * + * This method preserves consistency between a slice and its neighboring + * gates when one of them is contracted. + */ inline void update_adjacent_codomains() { if(prev_slice()) diff --git a/src/core/domains/tube/codac2_SliceBase.h b/src/core/domains/tube/codac2_SliceBase.h index 567f33140..5afcdad1c 100644 --- a/src/core/domains/tube/codac2_SliceBase.h +++ b/src/core/domains/tube/codac2_SliceBase.h @@ -18,26 +18,100 @@ namespace codac2 class TSlice; class SlicedTubeBase; + /** + * \class SliceBase + * \brief Base class for codomain slices attached to a temporal slice + * + * A ``SliceBase`` represents the codomain of a sliced tube over one temporal + * slice of a ``TDomain``. + * + * This abstract class stores: + * - a reference to the parent ``SlicedTubeBase``, + * - an iterator to the corresponding ``TSlice`` in the temporal partition. + * + * Concrete derived classes, such as ``Slice``, provide the actual codomain + * representation and the associated operations. + */ class SliceBase { public: - SliceBase(const SlicedTubeBase& tube, const std::list::iterator& it_tslice); + /** + * \brief Virtual destructor + */ + virtual ~SliceBase() = default; + /** + * \brief Duplicates this slice + * + * \return shared pointer to a copy of this slice + */ virtual std::shared_ptr copy() const = 0; + + /** + * \brief Initializes this slice to its unbounded codomain + */ virtual void init() = 0; + + /** + * \brief Sets this slice to the empty codomain + */ virtual void set_empty() = 0; + /** + * \brief Returns the temporal domain of this slice + * + * \return temporal interval associated with this slice + */ const Interval& t0_tf() const; + + /** + * \brief Returns the temporal slice associated with this object + * + * \return reference to the underlying ``TSlice`` + */ const TSlice& tslice() const; + /** + * \brief Returns the previous slice of the same tube + * + * The previous slice is searched in the temporal element preceding the + * current ``TSlice``. + * + * \return shared pointer to the previous slice, or ``nullptr`` if this + * slice is the first one + */ std::shared_ptr prev_slice() const; - std::shared_ptr next_slice() const; + /** + * \brief Returns the next slice of the same tube + * + * The next slice is searched in the temporal element following the current + * ``TSlice``. + * + * \return shared pointer to the next slice, or ``nullptr`` if this slice + * is the last one + */ + std::shared_ptr next_slice() const; protected: + + /** + * \brief Creates a slice attached to a tube and a temporal slice + * + * \param tube sliced tube owning this slice + * \param it_tslice iterator to the associated temporal slice + */ + SliceBase(const SlicedTubeBase& tube, const std::list::iterator& it_tslice); + /** + * \brief Parent sliced tube + */ const SlicedTubeBase& _tube; + + /** + * \brief Iterator to the associated temporal slice + */ std::list::iterator _it_tslice; friend class TDomain; diff --git a/src/core/domains/tube/codac2_SlicedTube.h b/src/core/domains/tube/codac2_SlicedTube.h index 6d9f7fd80..a26b8fa9a 100644 --- a/src/core/domains/tube/codac2_SlicedTube.h +++ b/src/core/domains/tube/codac2_SlicedTube.h @@ -13,14 +13,36 @@ #include "codac2_AnalyticFunction.h" #include "codac2_Tube_operator.h" #include "codac2_CtcDeriv.h" +#include "codac2_Scalar.h" namespace codac2 { + /** + * \class SlicedTube + * \brief Tube represented over a sliced temporal domain + * + * A ``SlicedTube`` is a tube whose temporal domain is represented by a + * shared ``TDomain`` made of ``TSlice`` objects. + * + * For each temporal slice of this partition, the tube stores a ``Slice`` + * describing the codomain of the tube over that temporal support. + * + * The codomain type ``T`` is typically ``Interval`` or ``IntervalVector``, + * or any custom domain implemented by the user. + * + * \tparam T codomain type of the tube + */ template class SlicedTube : public SlicedTubeBase { public: + /** + * \brief Creates a sliced tube with constant codomain over all temporal slices + * + * \param tdomain shared temporal domain of the tube + * \param codomain codomain assigned to each slice + */ explicit SlicedTube(const std::shared_ptr& tdomain, const T& codomain) : SlicedTubeBase(tdomain) @@ -32,6 +54,15 @@ namespace codac2 }); } + /** + * \brief Creates a sliced tube by evaluating an analytic function on each temporal slice + * + * The function is evaluated on each temporal interval of the associated + * ``TDomain``. + * + * \param tdomain shared temporal domain of the tube + * \param f analytic function of one scalar variable + */ explicit SlicedTube(const std::shared_ptr& tdomain, const AnalyticFunction::Type>& f) : SlicedTubeBase(tdomain) @@ -46,6 +77,13 @@ namespace codac2 }); } + /** + * \brief Creates a sliced tube from a sampled trajectory + * + * \tparam V sampled value type + * \param tdomain shared temporal domain of the tube + * \param f sampled trajectory evaluated on each temporal slice + */ template requires std::is_same_v::Domain,T> explicit SlicedTube(const std::shared_ptr& tdomain, @@ -59,6 +97,13 @@ namespace codac2 }); } + /** + * \brief Copy constructor + * + * The copied tube shares the same ``TDomain`` as the source tube. + * + * \param x tube to be copied + */ SlicedTube(const SlicedTube& x) : SlicedTubeBase(x.tdomain()) { @@ -69,6 +114,14 @@ namespace codac2 }); } + /** + * \brief Assignment operator + * + * Both tubes are expected to share the same temporal domain object. + * + * \param x source tube + * \return reference to this tube + */ inline SlicedTube& operator=(const SlicedTube& x) { assert_release(_tdomain == x._tdomain); @@ -79,11 +132,23 @@ namespace codac2 return *this; } + /** + * \brief Returns the codomain dimension + * + * \return dimension of the codomain type ``T`` + */ inline Index size() const { return first_slice()->size(); } + /** + * \brief Returns the matrix shape of this tube codomain + * + * For scalar codomains, the returned shape is ``{1,1}``. + * + * \return pair ``(rows, cols)`` + */ virtual std::pair shape() const { if constexpr(std::is_same_v::Type,ScalarType>) @@ -92,6 +157,13 @@ namespace codac2 return {first_slice()->codomain().rows(),first_slice()->codomain().cols()}; } + /** + * \brief Returns the volume of this tube + * + * Only non-gate slices contribute to the volume. + * + * \return sum of the volumes of all non-gate slices + */ inline double volume() const { double volume = 0.; @@ -101,66 +173,125 @@ namespace codac2 return volume; } + /** + * \brief Returns the first slice of this tube + * + * \return shared pointer to the first slice + */ inline std::shared_ptr> first_slice() { return std::const_pointer_cast>( static_cast(*this).first_slice()); } + /** + * \brief Returns the first slice of this tube + * + * \return shared pointer to the first slice + */ inline std::shared_ptr> first_slice() const { return std::static_pointer_cast>( this->SlicedTubeBase::first_slice()); } + /** + * \brief Returns the last slice of this tube + * + * \return shared pointer to the last slice + */ inline std::shared_ptr> last_slice() { return std::const_pointer_cast>( static_cast(*this).last_slice()); } + /** + * \brief Returns the last slice of this tube + * + * \return shared pointer to the last slice + */ inline std::shared_ptr> last_slice() const { return std::static_pointer_cast>( this->SlicedTubeBase::last_slice()); } + /** + * \brief Returns the slice attached to a temporal iterator + * + * \param it iterator to a ``TSlice`` of the shared ``TDomain`` + * \return shared pointer to the corresponding slice + */ inline std::shared_ptr> slice(const std::list::iterator& it) { return std::const_pointer_cast>( static_cast(*this).slice(it)); } + /** + * \brief Returns the slice attached to a temporal iterator + * + * \param it constant iterator to a ``TSlice`` of the shared ``TDomain`` + * \return shared pointer to the corresponding slice + */ inline std::shared_ptr> slice(const std::list::const_iterator& it) const { return std::static_pointer_cast>( it->slices().at(this)); } + /** + * \brief Returns the slice attached to a reverse temporal iterator + * + * \param it reverse iterator to a ``TSlice`` of the shared ``TDomain`` + * \return shared pointer to the corresponding slice + */ inline std::shared_ptr> slice(const std::list::reverse_iterator& it) { return std::const_pointer_cast>( static_cast(*this).slice(it)); } + /** + * \brief Returns the slice attached to a reverse temporal iterator + * + * \param it constant reverse iterator to a ``TSlice`` of the shared ``TDomain`` + * \return shared pointer to the corresponding slice + */ inline std::shared_ptr> slice(const std::list::const_reverse_iterator& it) const { return std::static_pointer_cast>( it->slices().at(this)); } + /** + * \brief Returns the slice attached to a temporal slice pointer + * + * This overload is mainly intended for language bindings. + * + * \param ptr pointer to a temporal slice of the shared ``TDomain`` + * \return shared pointer to the corresponding slice + */ inline std::shared_ptr> slice(std::shared_ptr ptr) { // Used in Python binding auto it = std::find_if(_tdomain->begin(), _tdomain->end(), [&](TSlice& t){ return &t == ptr.get(); }); + assert(it != _tdomain->end()); return slice(it); } + /** + * \brief Tests whether this tube is empty + * + * A fast evaluation is done by considering gates first, + * then envelopes, which allows to quickly identify an empty set + * + * \return ``true`` if at least one slice is empty, ``false`` otherwise + */ inline bool is_empty() const { - // Fast evaluation by considering gates first, then envelopes, - // which allows to quickly identify an empty set for(const auto& s : *this) if(s.is_gate() && s.is_empty()) return true; @@ -170,6 +301,11 @@ namespace codac2 return false; } + /** + * \brief Tests whether this tube is unbounded + * + * \return ``true`` if at least one slice is unbounded, ``false`` otherwise + */ inline bool is_unbounded() const { for(const auto& s : *this) @@ -178,6 +314,13 @@ namespace codac2 return false; } + /** + * \brief Returns the global codomain of this tube + * + * The returned codomain is the union of the codomains of all slices. + * + * \return global codomain enclosure + */ inline T codomain() const { T x = first_slice()->codomain(); @@ -206,6 +349,12 @@ namespace codac2 return codomain; } + /** + * \brief Evaluates this tube over a temporal interval + * + * \param t temporal interval + * \return enclosure of \f$[x]([t])\f$ + */ T operator()(const Interval& t) const { return eval_common(t, @@ -214,6 +363,13 @@ namespace codac2 }); } + /** + * \brief Returns the optimal evaluation over a temporal interval using a derivative tube + * + * \param t temporal interval + * \param v derivative tube such that \f$\dot{x}(\cdot)\in[v](\cdot)\f$ + * \return enclosure of \f$[x]([t])\f$ + */ T operator()(const Interval& t, const SlicedTube& v) const requires (std::is_same_v || std::is_same_v) { @@ -223,6 +379,12 @@ namespace codac2 }); } + /** + * \brief Returns enclosed lower and upper bounds over a temporal interval + * + * \param t temporal interval + * \return pair made of enclosed lower and upper bounds + */ std::pair enclosed_bounds(const Interval& t) const { auto x = this->empty_value(); @@ -250,6 +412,11 @@ namespace codac2 return bounds; } + /** + * \brief Sets all codomains of this tube to the same value + * + * \param codomain new codomain + */ inline void set(const T& codomain) { assert_release(codomain.size() == this->size()); @@ -263,12 +430,29 @@ namespace codac2 s.set(codomain, false); } + /** + * \brief Sets the codomain at one temporal instant + * + * The temporal domain may be refined so that ``t`` becomes an explicit gate. + * + * \param codomain new codomain + * \param t temporal instant + */ inline void set(const T& codomain, double t) { assert_release(codomain.size() == this->size()); slice(_tdomain->sample(t,true))->set(codomain); } + /** + * \brief Sets the codomain over a temporal interval + * + * The temporal domain may be refined so that the bounds of ``t`` become + * explicit gates. + * + * \param codomain new codomain + * \param t temporal interval + */ inline void set(const T& codomain, const Interval& t) { auto it_lb = _tdomain->sample(t.lb(), t.is_degenerated()); @@ -294,6 +478,12 @@ namespace codac2 } while(it_lb != it_ub && (++it_lb) != _tdomain->end()); } + /** + * \brief Sets the codomain of the \f$i\f$-th stored slice + * + * \param codomain new codomain + * \param i slice index + */ inline void set_ith_slice(const T& codomain, Index i) { Index j = 0; @@ -305,6 +495,13 @@ namespace codac2 } } + /** + * \brief Inflates this tube by a constant radius + * + * \tparam V radius type + * \param rad inflation radius + * \return reference to this tube + */ template requires (std::is_same_v::Domain,T> || std::is_same_v) const SlicedTube& inflate(const V& rad) @@ -321,6 +518,13 @@ namespace codac2 return *this; } + /** + * \brief Inflates this tube by a time-varying sampled radius + * + * \tparam V sampled radius type + * \param rad sampled inflation radius + * \return reference to this tube + */ template requires (std::is_same_v::Domain,T> || std::is_same_v) const SlicedTube& inflate(const SampledTraj& rad) @@ -339,6 +543,12 @@ namespace codac2 return *this; } + /** + * \brief Extracts one scalar component of this tube + * + * \param i component index + * \return scalar sliced tube corresponding to the \f$i\f$-th component + */ SlicedTube operator[](Index i) const { assert_release(i >= 0 && i < size()); @@ -348,6 +558,13 @@ namespace codac2 return xi; } + /** + * \brief Extracts a subvector of this tube + * + * \param i first component index + * \param j last component index + * \return sliced tube associated with the subvector \f$[i,j]\f$ + */ SlicedTube subvector(Index i, Index j) const { assert_release(i >= 0 && i <= j && j < size()); @@ -357,6 +574,15 @@ namespace codac2 return xij; } + /** + * \brief Compares two sliced tubes + * + * Two sliced tubes are equal if they share the same temporal partition and + * if all corresponding codomains are equal. + * + * \param x tube to compare with + * \return ``true`` if both tubes are equal, ``false`` otherwise + */ inline bool operator==(const SlicedTube& x) const { if(!TDomain::are_same(tdomain(), x.tdomain())) @@ -372,7 +598,15 @@ namespace codac2 return true; } - inline SlicedTube operator&=(const SlicedTube& x) + /** + * \brief Intersects this tube with another one + * + * Both tubes are expected to be defined over the same temporal partition. + * + * \param x tube to intersect with + * \return updated tube + */ + inline SlicedTube& operator&=(const SlicedTube& x) { assert(TDomain::are_same(tdomain(), x.tdomain())); auto it_this = _tdomain->begin(); @@ -389,6 +623,13 @@ namespace codac2 return *this; } + /** + * \brief Stream output for a sliced tube + * + * \param os output stream + * \param x sliced tube to display + * \return reference to the output stream + */ friend inline std::ostream& operator<<(std::ostream& os, const SlicedTube& x) { os << x.t0_tf() @@ -399,6 +640,12 @@ namespace codac2 return os; } + /** + * \brief Returns an analytic wrapper of this tube, allowing to + * evaluate this tube as an operator in an analytic expression. + * + * \return analytic function associated with this tube + */ AnalyticFunction::Type> as_function() const { ScalarVar t; @@ -555,11 +802,94 @@ namespace codac2 // Integral related methods + /** + * \brief Returns an enclosure of the integral of this tube from \f$t_0\f$ to \f$[t]\f$ + * + * This method computes an enclosure of + * \f[ + * \left\{ \int_{t_0}^{\tau} x(s)\,ds \;\middle|\; \tau\in[t] \right\}. + * \f] + * + * It is obtained from ``partial_integral(t)`` by taking the hull between + * the lower bound of the lower enclosure and the upper bound of the upper + * enclosure. + * + * \param t temporal interval + * \return enclosure of the partial integral of this tube over ``t`` + */ T integral(const Interval& t) const; + + /** + * \brief Returns an enclosure of the integral of this tube between \f$[t_1]\f$ and \f$[t_2]\f$ + * + * This method computes an enclosure of + * \f[ + * \left\{ \int_{\tau_1}^{\tau_2} x(s)\,ds + * \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] \right\}. + * \f] + * + * The result is obtained by subtracting the partial integral enclosures at + * ``t1`` and ``t2``. + * + * \param t1 first temporal interval + * \param t2 second temporal interval + * \return enclosure of the integral of this tube between ``t1`` and ``t2`` + */ T integral(const Interval& t1, const Interval& t2) const; + + /** + * \brief Returns lower and upper enclosures of the primitive of this tube over \f$[t]\f$ + * + * This method returns a pair ``(p⁻,p⁺)`` such that, for every + * \f$\tau\in[t]\f$, + * \f[ + * \int_{t_0}^{\tau} x(s)\,ds \in [\,p^-,\,p^+\,]. + * \f] + * + * More precisely: + * - ``first`` encloses the lower bounds of the partial integrals, + * - ``second`` encloses the upper bounds of the partial integrals. + * + * This representation preserves more information than ``integral(t)``, + * which only returns the hull of these partial integral bounds. + * + * \param t temporal interval + * \return pair of lower and upper partial integral enclosures over ``t`` + */ std::pair partial_integral(const Interval& t) const; + + /** + * \brief Returns lower and upper enclosures of the primitive increment between \f$[t_1]\f$ and \f$[t_2]\f$ + * + * This method returns a pair obtained by subtracting the partial integral + * enclosures at ``t1`` from those at ``t2``. + * + * It provides lower and upper enclosures of + * \f[ + * \int_{\tau_1}^{\tau_2} x(s)\,ds, + * \qquad \tau_1\in[t_1],\ \tau_2\in[t_2]. + * \f] + * + * \param t1 first temporal interval + * \param t2 second temporal interval + * \return pair of lower and upper enclosures of the integral increment + */ std::pair partial_integral(const Interval& t1, const Interval& t2) const; + /** + * \brief Returns a primitive of this tube with zero initial condition + * + * This is a shorthand for ``primitive(x0)`` with \f$x_0 = 0\f$. + * + * The returned tube ``p`` is defined on the same temporal domain and + * satisfies the derivative relation + * \f[ + * \dot{p}(\cdot) \in [x](\cdot), + * \f] + * together with the initial condition \f$p(t_0)=0\f$. + * + * \return primitive tube with zero initial condition + */ inline SlicedTube primitive() const { auto x0 = all_reals_value(); @@ -567,6 +897,26 @@ namespace codac2 return primitive(x0); } + /** + * \brief Returns a primitive of this tube with prescribed initial condition + * + * This method constructs a tube ``p`` on the same temporal domain as this + * tube, imposes the initial condition \f$p(t_0)=x_0\f$, and contracts + * ``p`` with ``*this`` through the derivative relation using ``CtcDeriv``. + * + * In other words, the returned tube encloses solutions of + * \f[ + * \dot{p}(\cdot) \in [x](\cdot), + * \qquad p(t_0)=x_0. + * \f] + * + * \note The current implementation may create an explicit gate at the + * initial time \f$t_0\f$ if it is not already present in the + * temporal partition. + * + * \param x0 initial condition at \f$t_0\f$ + * \return primitive tube satisfying the prescribed initial condition + */ inline SlicedTube primitive(const T& x0) const { auto x = all_reals_value(); @@ -577,6 +927,11 @@ namespace codac2 return p; } + /** + * \brief Returns the unbounded codomain value associated with ``T`` + * + * \return unbounded value of type ``T`` + */ inline T all_reals_value() const { T x = first_slice()->codomain(); @@ -584,6 +939,11 @@ namespace codac2 return x; } + /** + * \brief Returns the empty codomain value associated with ``T`` + * + * \return empty value of type ``T`` + */ inline T empty_value() const { T x = first_slice()->codomain(); @@ -591,11 +951,15 @@ namespace codac2 return x; } - template - // requires std::is_same_v::Domain,T> - inline auto mid() const + /** + * \brief Returns the approximated midpoint trajectory of this tube + * + * \tparam V sampled value type + * \return midpoint sampled trajectory + */ + inline SampledTraj::Type> mid() const { - SampledTraj m; + SampledTraj::Type> m; double t0 = _tdomain->t0_tf().lb(); m.set((*this)(t0).mid(), t0); for(const auto& s : *this) @@ -609,6 +973,9 @@ namespace codac2 using base_container = std::list; + /** + * \brief Mutable iterator over the slices of this tube + */ struct iterator : public base_container::iterator { public: @@ -631,9 +998,19 @@ namespace codac2 SlicedTube& _x; }; + /** + * \brief Returns an iterator to the first temporal slice + */ iterator begin() { return { *this, _tdomain->begin() }; } + + /** + * \brief Returns an iterator past the last temporal slice + */ iterator end() { return { *this, _tdomain->end() }; } + /** + * \brief Mutable reverse iterator over the slices of this tube + */ struct reverse_iterator : public base_container::reverse_iterator { public: @@ -656,9 +1033,19 @@ namespace codac2 SlicedTube& _x; }; + /** + * \brief Returns a reverse iterator to the last temporal slice + */ reverse_iterator rbegin() { return { *this, _tdomain->rbegin() }; } + + /** + * \brief Returns a reverse iterator past the first temporal slice + */ reverse_iterator rend() { return { *this, _tdomain->rend() }; } + /** + * \brief Constant iterator over the slices of this tube + */ struct const_iterator : public base_container::const_iterator { public: @@ -681,9 +1068,19 @@ namespace codac2 const SlicedTube& _x; }; + /** + * \brief Returns a constant iterator to the first temporal slice + */ const_iterator begin() const { return { *this, _tdomain->cbegin() }; } + + /** + * \brief Returns a constant iterator past the last temporal slice + */ const_iterator end() const { return { *this, _tdomain->cend() }; } + /** + * \brief Constant reverse iterator over the slices of this tube + */ struct const_reverse_iterator : public base_container::const_reverse_iterator { public: @@ -706,7 +1103,14 @@ namespace codac2 const SlicedTube& _x; }; + /** + * \brief Returns a constant reverse iterator to the last temporal slice + */ const_reverse_iterator rbegin() const { return { *this, _tdomain->crbegin() }; } + + /** + * \brief Returns a constant reverse iterator past the first temporal slice + */ const_reverse_iterator rend() const { return { *this, _tdomain->crend() }; } }; @@ -727,8 +1131,8 @@ namespace codac2 template inline void CtcBase::contract(SlicedTube&... x) const { - auto tdomain = std::get<0>(std::make_tuple(x...)); - for(auto it = tdomain.begin() ; it != tdomain.end() ; it++) + auto&& x0 = std::get<0>(std::forward_as_tuple(x...)); + for(auto it = x0.begin(); it != x0.end(); ++it) contract((x.slice(it)->codomain())...); } diff --git a/src/core/domains/tube/codac2_SlicedTubeBase.h b/src/core/domains/tube/codac2_SlicedTubeBase.h index 8616ef77f..072b653de 100644 --- a/src/core/domains/tube/codac2_SlicedTubeBase.h +++ b/src/core/domains/tube/codac2_SlicedTubeBase.h @@ -14,25 +14,70 @@ namespace codac2 { + /** + * \class SlicedTubeBase + * \brief Base class for tubes defined over a sliced temporal domain + * + * A ``SlicedTubeBase`` is a tube whose temporal domain is represented by a + * ``TDomain`` made of ``TSlice`` objects. + * + * This class provides common services for all sliced tubes: + * - access to the number of temporal elements, + * - access to the first and last codomain slices, + * - cleanup of the links stored in the temporal partition when the tube is + * destroyed. + * + * Each ``TSlice`` of the associated ``TDomain`` stores a map from + * ``SlicedTubeBase*`` to ``SliceBase``. The destructor of this class removes + * the entries associated with the current tube. + */ class SlicedTubeBase : public TubeBase { public: + /** + * \brief Creates a sliced tube over a given temporal domain + * + * \param tdomain shared temporal domain of this tube + */ SlicedTubeBase(const std::shared_ptr& tdomain) : TubeBase(tdomain) { } + /** + * \brief Destroys this sliced tube + * + * All references to this tube stored in the ``TSlice`` objects of the + * associated ``TDomain`` are removed. + */ inline ~SlicedTubeBase() { for(auto& s : *_tdomain) s._slices.erase(this); } + /** + * \brief Returns the number of temporal elements of this tube + * + * The count includes all elements stored in the temporal partition, + * including explicit gates if they exist. + * + * \return number of temporal slices of the associated ``TDomain`` + */ inline size_t nb_slices() const { return _tdomain->nb_tslices(); } + /** + * \brief Returns the first slice of this tube + * + * \note This method assumes that the associated temporal domain is not + * empty and that its first ``TSlice`` contains a slice attached to + * this tube. + * + * \return shared pointer to the first slice + */ inline std::shared_ptr first_slice() const { const auto& slices = _tdomain->front().slices(); @@ -40,6 +85,15 @@ namespace codac2 return slices.at(this); } + /** + * \brief Returns the last slice of this tube + * + * \note This method assumes that the associated temporal domain is not + * empty and that its last ``TSlice`` contains a slice attached to + * this tube. + * + * \return shared pointer to the last slice + */ inline std::shared_ptr last_slice() const { const auto& slices = _tdomain->back().slices(); diff --git a/src/core/domains/tube/codac2_TDomain.cpp b/src/core/domains/tube/codac2_TDomain.cpp index 8b2a742a8..3d6260949 100644 --- a/src/core/domains/tube/codac2_TDomain.cpp +++ b/src/core/domains/tube/codac2_TDomain.cpp @@ -58,32 +58,22 @@ namespace codac2 bool TDomain::all_gates_defined() const { - if(t0_tf().is_degenerated()) - return true; - - else if(nb_tslices() == 1) + if(this->empty()) return false; - - else + + bool expect_gate = true; + + for(const auto& s : *this) { - list::const_iterator it = std::next(this->begin()); - while(it != this->end()) - { - if(it->is_gate()) - return false; - - it++; - - if(it != this->end()) - { - if(!it->is_gate()) - return false; - it++; - } - } - - return true; + if(s.is_gate() != expect_gate) + return false; + + expect_gate = !expect_gate; } + + // We must end on a gate: + // valid patterns are [gate] or [gate, slice, ..., gate] + return !expect_gate; } std::vector TDomain::tslices_vector() const @@ -212,6 +202,7 @@ namespace codac2 void TDomain::truncate(const Interval& new_tdomain) { + assert_release(new_tdomain.is_subset(t0_tf())); sample(new_tdomain.lb()); sample(new_tdomain.ub()); this->remove_if( diff --git a/src/core/domains/tube/codac2_TSlice.cpp b/src/core/domains/tube/codac2_TSlice.cpp index 778e241e6..0377e24ad 100644 --- a/src/core/domains/tube/codac2_TSlice.cpp +++ b/src/core/domains/tube/codac2_TSlice.cpp @@ -35,14 +35,4 @@ namespace codac2 { return _slices; } - - bool TSlice::operator==(const TSlice& x) const - { - return Interval::operator==(x); - } - - bool TSlice::operator==(const Interval& x) const - { - return Interval::operator==(x); - } } \ No newline at end of file diff --git a/src/core/domains/tube/codac2_TSlice.h b/src/core/domains/tube/codac2_TSlice.h index 11d95c8de..81edf9c59 100644 --- a/src/core/domains/tube/codac2_TSlice.h +++ b/src/core/domains/tube/codac2_TSlice.h @@ -18,19 +18,68 @@ namespace codac2 class SliceBase; class SlicedTubeBase; + /** + * \class TSlice + * \brief Temporal slice shared by sliced tubes. + * + * A ``TSlice`` represents a temporal interval of a ``TDomain``. + * It inherits from ``Interval`` and may correspond either to: + * - a non-degenerate time slice \f$[t_i,t_{i+1}]\f$, or + * - a degenerate interval \f$[t_i,t_i]\f$, referred to as a gate. + * + * For each sliced tube defined on the same temporal partition, this object + * stores the corresponding ``SliceBase`` instance. + */ class TSlice : public Interval { public: + /** + * \brief Creates a temporal slice over the given time interval + * + * \param tdomain temporal interval associated with this slice + */ explicit TSlice(const Interval& tdomain); + + /** + * \brief Creates a temporal slice from another one over a new time interval + * + * This constructor duplicates the slice container associated with each + * tube by performing a deep copy of the underlying ``SliceBase`` objects. + * + * \param tslice source temporal slice + * \param tdomain temporal interval associated with the copied slice + */ TSlice(const TSlice& tslice, const Interval& tdomain); // performs a deep copy on slices + + /** + * \brief Tests whether this temporal slice is a gate + * + * A temporal slice is considered as a gate when its temporal interval is + * degenerate, i.e., when \f$t^-=t^+\f$. + * + * \return ``true`` if this slice is a gate, ``false`` otherwise + */ bool is_gate() const; + + /** + * \brief Returns the slices attached to this temporal slice + * + * The returned map associates each ``SlicedTubeBase`` defined on the same + * temporal partition with its corresponding ``SliceBase`` over this + * temporal interval. + * + * \return constant reference to the map of attached slices + */ const std::map>& slices() const; - bool operator==(const TSlice& x) const; - bool operator==(const Interval& x) const; + + using Interval::operator==; protected: + /** + * \brief Slices attached to each sliced tube over this temporal interval + */ std::map> _slices; friend class TDomain; diff --git a/src/core/domains/tube/codac2_TubeBase.h b/src/core/domains/tube/codac2_TubeBase.h index fde7ac85e..b3bec8b28 100644 --- a/src/core/domains/tube/codac2_TubeBase.h +++ b/src/core/domains/tube/codac2_TubeBase.h @@ -14,19 +14,50 @@ namespace codac2 { + /** + * \class TubeBase + * \brief Base class for tubes defined over a temporal domain + * + * A ``TubeBase`` stores the temporal domain shared by a tube. + * This temporal domain is represented by a ``TDomain`` object and defines the + * global time interval \f$[t_0,t_f]\f$ on which the tube is defined. + * + * This class provides common services for all tube types: + * - access to the underlying temporal domain, + * - access to its global temporal interval. + */ class TubeBase : public Domain { public: - TubeBase(const std::shared_ptr& tdomain) + /** + * \brief Creates a tube over a given temporal domain + * + * \param tdomain shared temporal domain of this tube + */ + explicit TubeBase(const std::shared_ptr& tdomain) : _tdomain(tdomain) - { } + { + assert_release(tdomain != nullptr); + } + /** + * \brief Returns the temporal domain of this tube + * + * \return shared pointer to the associated ``TDomain`` + */ inline const std::shared_ptr& tdomain() const { return _tdomain; } + /** + * \brief Returns the global temporal interval of this tube + * + * This method is a shortcut to ``tdomain()->t0_tf()``. + * + * \return temporal interval \f$[t_0,t_f]\f$ of this tube + */ inline Interval t0_tf() const { return _tdomain->t0_tf(); @@ -34,6 +65,9 @@ namespace codac2 protected: + /** + * \brief Shared temporal domain of this tube + */ const std::shared_ptr _tdomain; }; } \ No newline at end of file diff --git a/src/core/domains/tube/codac2_tube_cart_prod.h b/src/core/domains/tube/codac2_tube_cart_prod.h index 0ed3a947e..ac4083647 100644 --- a/src/core/domains/tube/codac2_tube_cart_prod.h +++ b/src/core/domains/tube/codac2_tube_cart_prod.h @@ -9,18 +9,39 @@ #pragma once +#include #include "codac2_cart_prod.h" #include "codac2_SlicedTube.h" namespace codac2 { + /** + * \brief Computes the Cartesian product of several sliced tubes + * + * This function builds a vector-valued sliced tube whose temporal domain is + * shared with the input tubes. For each temporal slice, the codomain of the + * resulting tube is the Cartesian product of the codomains of the input tubes + * over the same temporal slice. + * + * The dimension of the resulting codomain is equal to the sum of the + * dimensions of all input tubes. + * + * \note All input tubes must share the same temporal partition. + * + * \tparam X types of the input sliced tubes + * \param x input sliced tubes + * \return a sliced tube enclosing the Cartesian product of the input tubes + */ template SlicedTube tube_cart_prod(const X&... x) { + static_assert(sizeof...(X) > 0, "tube_cart_prod requires at least one tube"); Index s = 0; ((s += x.size()), ...); - auto tdomain = std::get<0>(std::make_tuple(x...)).tdomain(); + const auto& x0 = std::get<0>(std::forward_as_tuple(x...)); + auto tdomain = x0.tdomain(); + assert_release(((x.tdomain() == tdomain) && ...)); SlicedTube v(tdomain, IntervalVector(s)); for(auto it = tdomain->begin() ; it != tdomain->end() ; it++) From 6433db194ac5d6c6621cfc3c5d6975f81abe9277 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Wed, 15 Apr 2026 21:00:16 +0200 Subject: [PATCH 04/21] [doc] manual for tubes --- doc/manual/_static/css/custom.css | 6 +- doc/manual/index.rst | 1 + .../functions/analytic/analytic_operators.rst | 6 +- doc/manual/manual/tubes/index.rst | 65 +++ doc/manual/manual/tubes/interval_trajs.png | Bin 0 -> 85427 bytes doc/manual/manual/tubes/inversion_example.png | Bin 0 -> 77738 bytes doc/manual/manual/tubes/slicedtube.rst | 417 ++++++++++++++++++ doc/manual/manual/tubes/tdomain.rst | 238 ++++++++++ doc/manual/manual/tubes/tube_integ_inf.png | Bin 0 -> 160142 bytes .../manual/tubes/tube_lb_integral_slices.png | Bin 0 -> 185746 bytes doc/manual/manual/tubes/tube_slices.png | Bin 0 -> 184080 bytes 11 files changed, 728 insertions(+), 5 deletions(-) create mode 100644 doc/manual/manual/tubes/index.rst create mode 100644 doc/manual/manual/tubes/interval_trajs.png create mode 100644 doc/manual/manual/tubes/inversion_example.png create mode 100644 doc/manual/manual/tubes/slicedtube.rst create mode 100644 doc/manual/manual/tubes/tdomain.rst create mode 100644 doc/manual/manual/tubes/tube_integ_inf.png create mode 100644 doc/manual/manual/tubes/tube_lb_integral_slices.png create mode 100644 doc/manual/manual/tubes/tube_slices.png diff --git a/doc/manual/_static/css/custom.css b/doc/manual/_static/css/custom.css index 7db716235..15d67c7a3 100644 --- a/doc/manual/_static/css/custom.css +++ b/doc/manual/_static/css/custom.css @@ -179,16 +179,16 @@ a .download:before { } /* Adding VIBes + IPE logos in the lateral menu */ -.sidebar-tree li.toctree-l1 > a.reference.internal:has(+ input#toctree-checkbox-8) { +.sidebar-tree li.toctree-l1 > a.reference.internal:has(+ input#toctree-checkbox-9) { background:url("../logos/logos_vibes_ipe.png") no-repeat center / contain; } -.sidebar-tree li.toctree-l1 > a.reference.internal:has(+ input#toctree-checkbox-8):hover { +.sidebar-tree li.toctree-l1 > a.reference.internal:has(+ input#toctree-checkbox-9):hover { background: url("../logos/logos_vibes_ipe.png") no-repeat center / contain, var(--color-sidebar-item-background--hover); } -.sidebar-tree li.toctree-l1 > a.reference.internal.current:has(+ input#toctree-checkbox-8) { +.sidebar-tree li.toctree-l1 > a.reference.internal.current:has(+ input#toctree-checkbox-9) { background: url("../logos/logos_vibes_ipe.png") no-repeat center / contain, var(--color-sidebar-item-background--current); } \ No newline at end of file diff --git a/doc/manual/index.rst b/doc/manual/index.rst index 3ad3e0a2c..eab110345 100644 --- a/doc/manual/index.rst +++ b/doc/manual/index.rst @@ -401,6 +401,7 @@ Development manual/introduction/index.rst manual/installation/index.rst manual/intervals/index.rst + manual/tubes/index.rst manual/linear/index.rst manual/functions/index.rst manual/contractors/index.rst diff --git a/doc/manual/manual/functions/analytic/analytic_operators.rst b/doc/manual/manual/functions/analytic/analytic_operators.rst index 4262b4644..f1c8a3a19 100644 --- a/doc/manual/manual/functions/analytic/analytic_operators.rst +++ b/doc/manual/manual/functions/analytic/analytic_operators.rst @@ -321,6 +321,8 @@ Expressions involving a non-supported centered-form operation If an operator, for which the centered form is not defined, is involved in an expression, then this expression cannot be evaluated using the centered form (calculation is disabled for the entire operation). A simple natural evaluation will then be computed. +.. _sec-functions-temporal-operator: + Expressions involving a temporal operator ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -330,7 +332,7 @@ Temporal operations for involving trajectories or tubes in analytic expressions .. code-tab:: py - x = # some sampled trajectory... + x = # some tube or sampled trajectory... g = x.as_function() # intermediate operation t = ScalarVar() @@ -340,7 +342,7 @@ Temporal operations for involving trajectories or tubes in analytic expressions .. code-tab:: c++ - x = // some sampled trajectory... + x = // some tube or sampled trajectory... g = x.as_function(); // intermediate operation ScalarVar t; diff --git a/doc/manual/manual/tubes/index.rst b/doc/manual/manual/tubes/index.rst new file mode 100644 index 000000000..885fc32c3 --- /dev/null +++ b/doc/manual/manual/tubes/index.rst @@ -0,0 +1,65 @@ +.. _sec-domains-tubes: + +Tubes +===== + + Main author: `Simon Rohou `_ + +Introduction +------------ + +A tube is a set of trajectories. More precisely, if :math:`\mathcal{F}(\mathbb{R}\to\mathbb{R}^n)` denotes the set of trajectories with values in :math:`\mathbb{R}^n`, a tube :math:`\mathbb{X}(\cdot)` is a set-valued map + +.. math:: + + \mathbb{X}(\cdot): \mathbb{R} \to \mathcal{P}(\mathbb{R}^n) + +such that + +.. math:: + + \mathbf{x}(\cdot)\in\mathbb{X}(\cdot) + \;\Longleftrightarrow\; + \forall t,\ \mathbf{x}(t)\in\mathbb{X}(t). + +In other words, a tube encloses trajectories pointwise in time: for every time :math:`t`, the value :math:`\mathbf{x}(t)` must belong to the set :math:`\mathbb{X}(t)`. This definition is intentionally general. It does not encode additional temporal information such as continuity, monotonicity, or derivative constraints. Such properties may be handled separately, for instance by contractors or by combining several tubes. + +This point of view naturally extends interval and box representations. In the most common cases, :math:`\mathbb{X}(t)` is an interval, a box, or a matrix of intervals, but in principle it may be any codomain type for which suitable set operations are available. + +In Codac C++, this generality is reflected by the template ``SlicedTube``. In principle, ``T`` can be any codomain type compatible with the sliced-tube algorithms. +The library naturally provides and primarily uses: + +* ``SlicedTube``, +* ``SlicedTube``, +* ``SlicedTube``. + +These are the most common tube types in practice. In Python and Matlab, only these standard sliced-tube classes are currently exposed through the bindings. + +This chapter documents the *sliced tube* implementation currently available in Codac. In this implementation, a tube is represented over an explicit temporal partition stored in a :class:`~codac.TDomain`. Each temporal element is a :class:`~codac.TSlice`, and each application-level value over one temporal element is represented by a :class:`~codac.Slice`. The main user-facing object is therefore a :class:`~codac.SlicedTube`. + +.. figure:: ./tube_slices.png + :width: 70% + + An example of sliced tube :math:`[x](\cdot)`, as implemented in Codac. The tube is made as a list of interval or box slices. In practice, the sampling :math:`\delta` is not necessarily constant. + +Compared with the previous Codac v1 implementation, these tubes are not only functions of time: they are also shared data structures built on a common temporal partition. Refining the time partition of one tube may therefore update the internal slice structure of all tubes attached to the same :class:`~codac.TDomain`. This design is central to the current implementation. It simplifies the user experience: a temporal modification applied to one tube is implicitly propagated to the others, so multi-tube operations such as arithmetic combinations or contractions can still be performed easily on a consistent shared time basis. + +Conceptually, the data model is: + +.. code-block:: text + + TDomain + ├── TSlice #0 ----> Slice for tube x + │ └-> Slice for tube y + ├── TSlice #1 ----> Slice for tube x + │ └-> Slice for tube y + └── ... + + +This chapter is organized as follows: + +.. toctree:: + :maxdepth: 1 + + tdomain + slicedtube \ No newline at end of file diff --git a/doc/manual/manual/tubes/interval_trajs.png b/doc/manual/manual/tubes/interval_trajs.png new file mode 100644 index 0000000000000000000000000000000000000000..8533ce3c99694e8574b5bd3a84f04bdaf4ca9041 GIT binary patch literal 85427 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 A-T(jq literal 0 HcmV?d00001 diff --git a/doc/manual/manual/tubes/slicedtube.rst b/doc/manual/manual/tubes/slicedtube.rst new file mode 100644 index 000000000..19714943c --- /dev/null +++ b/doc/manual/manual/tubes/slicedtube.rst @@ -0,0 +1,417 @@ +.. _sec-domains-slicedtube: + +The SlicedTube class +==================== + + Main author: `Simon Rohou `_ + +A :class:`~codac.SlicedTube` is a tube defined over a shared :class:`~codac.TDomain`. +For each temporal slice stored in the temporal partition, the tube owns one :class:`~codac.Slice` object storing its codomain over that temporal support. The codomain type is typically :class:`~codac.Interval` or :class:`~codac.IntervalVector`, or any domain type defined by the user. The same temporal domain can be shared by many tubes. + + +Creating sliced tubes +--------------------- + +In Codac C++, :class:`~codac.SlicedTube` is a generic class template ``SlicedTube``. The codomain type ``T`` is not restricted to intervals or boxes: in principle, any domain type compatible with the sliced-tube API can be used. + +In practice, the most common sliced-tube types are: + +* ``SlicedTube``, +* ``SlicedTube``, +* ``SlicedTube``. + +These standard tube types are also the ones exposed in the Python and Matlab bindings. + +In C++, template argument deduction is available for the constructors based on the arguments. In the examples below, comments make the deduced type explicit when useful. + +A sliced tube can be created from: + +* a constant codomain, +* an analytic function of one scalar variable, +* a sampled or an analytic trajectory, +* or another sliced tube (copy constructor). + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,10], 0.1, True) + + # Sliced tube from interval-type codomains + x = SlicedTube(td, Interval(-1,1)) + y = SlicedTube(td, IntervalVector(2)) + z = SlicedTube(td, IntervalMatrix(2,2)) + + # From an analytic function + t = ScalarVar() + f = AnalyticFunction([t], sin(t)) + xf = SlicedTube(td, f) + + # From an analytic trajectory or sampled trajectory + at = AnalyticTraj(AnalyticFunction([t],cos(t)), [0,10]) + st = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), [0,10]).sampled(1e-2) + xu = SlicedTube(td,at) | SlicedTube(td,st) # union (hull) of tubes + + fig.plot_tube(xf, [Color.dark_blue(),Color.light_gray()]) + fig.plot_tube(xu, [Color.dark_blue(),Color.light_gray()]) + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,10}, 0.1, true); + + // Sliced tube from interval-type codomains + SlicedTube x(td, Interval(-1,1)); // x has type SlicedTube + SlicedTube y(td, IntervalVector(2)); // y has type SlicedTube + SlicedTube z(td, IntervalMatrix(2,2)); // z has type SlicedTube + + // Explicit template notation remains possible: + SlicedTube x2(td, Interval(-1,1)); + + // From an analytic function + ScalarVar t; + AnalyticFunction f({t}, sin(t)); + SlicedTube xf(td, f); + // xf has type SlicedTube because f outputs scalar values + + // From an analytic trajectory or sampled trajectory + AnalyticTraj at(AnalyticFunction({t},cos(t)), {0,10}); + AnalyticTraj st(AnalyticFunction({t},cos(t)+t/10), {0,10}).sampled(1e-2); + auto xu = SlicedTube(td,at) | SlicedTube(td,st); // union (hull) of tubes + + fig.plot_tube(xf, {Color::dark_blue(),Color::light_gray()}); + fig.plot_tube(xu, {Color::dark_blue(),Color::light_gray()}); + + +.. figure:: interval_trajs.png + :width: 70% + + Created tubes :math:`[x_f](\cdot)=[\sin(\cdot),\sin(\cdot)]` and :math:`[x_u](\cdot)=[\cos(\cdot),\cos(\cdot)+\frac{\cdot}{10}]`, made of 100 slices. + + +Basic properties +---------------- + +A sliced tube exposes: + +* ``size()`` for the codomain dimension, +* ``shape()`` for matrix-like codomain shapes, +* ``tdomain()`` and ``t0_tf()`` from the base classes, +* ``nb_slices()`` for the number of temporal elements, +* ``codomain()`` for the global codomain hull, +* ``volume()`` for the sum of non-gate slice volumes, +* ``is_empty()`` and ``is_unbounded()``. + +Accessing slices and iterating +------------------------------ + +You can access the first and last slices directly: + +* ``first_slice()`` +* ``last_slice()`` + +and you can retrieve a slice from a temporal-domain iterator or from a ``TSlice`` pointer. +The class also defines custom iterators so that iterating on a ``SlicedTube`` yields application-level :class:`~codac.Slice` objects rather than raw ``TSlice`` objects. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,3]) + x = SlicedTube(td, IntervalVector(2)) + x.set([[1,5],[-oo,2]], [0,1]) + x.set([[2,8],[-oo,3]], [1,2]) + x.set([[6,9],[-oo,4]], [2,3]) + + s0 = x.first_slice() + s1 = s0.next_slice() + + for s in x: + print(s.t0_tf(), s.codomain()) + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,3}); + SlicedTube x(td, IntervalVector(2)); + x.set({{1,5},{-oo,2}}, {0,1}); + x.set({{2,8},{-oo,3}}, {1,2}); + x.set({{6,9},{-oo,4}}, {2,3}); + + auto s0 = x.first_slice(); + auto s1 = s0->next_slice(); + + for(const auto& s : x) + std::cout << s.t0_tf() << " -> " << s.codomain() << std::endl; + + +Setting values and refining the partition +----------------------------------------- + +A sliced tube can be updated globally or locally: + +* ``set(codomain)`` sets all slices to the same codomain, +* ``set(codomain, t)`` sets the value at one time instant, +* ``set(codomain, [ta,tb])`` sets all temporal elements intersecting an interval, +* ``set_ith_slice(codomain, i)`` sets one stored slice by index. + +The key point is that local assignments may refine the underlying :class:`~codac.TDomain`. +For example, setting a value at one scalar time creates an explicit gate if necessary. Similarly, setting a value over an interval may create new temporal boundaries at the interval endpoints. + +.. note:: + + Because the temporal domain is shared, such refinements are structural operations. If several tubes share the same ``TDomain``, all of them will observe the new partition. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,2], 1.0, False) # False: without gates + + x = SlicedTube(td, Interval(0,1)) + v = SlicedTube(td, Interval(-1,1)) + + print(x) # outputs [0,2]↦[0,1], 2 slices + print(v) # outputs [0,2]↦[0,1], 2 slices + + td.nb_tslices() # 2: [0,1],[1,2] + x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 + td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + print(x) # outputs [0,2]↦[-1,1], 4 slices + print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,2}, 1.0, false); // false: without gates + + SlicedTube x(td, Interval(0,1)); + SlicedTube v(td, Interval(-1,1)); + + cout << x << endl; // outputs [0,2]↦[0,1], 2 slices + cout << v << endl; // outputs [0,2]↦[0,1], 2 slices + + td->nb_tslices(); // 2: [0,1],[1,2] + x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 + td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices + cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + + +Evaluation +---------- + +A sliced tube :math:`[x](\cdot)` can be evaluated over a temporal interval :math:`[t]` with ``x(t)``. The implementation walks through all relevant temporal slices, evaluates each local slice, and unions the results. If the query interval is not included in the temporal domain, the result is the unbounded value of the codomain type (for interval tubes: :math:`[-\infty,\infty]`). + +When a derivative tube ``v`` is available, the overload ``x(t,v)`` uses per-slice derivative-aware evaluation and unions the resulting enclosures. This is available for ``Interval`` and ``IntervalVector`` codomain types. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,3], 1.0, False) + x = SlicedTube(td, Interval()) + + x.set([1,5], [0,1]) + x.set([2,8], [1,2]) + x.set([6,9], [2,3]) + + x(0.5) # [1,5] + x(1.5) # [2,8] + x([0,3]) # [1,9] + x(-1.0) # [-oo,oo] + + # No explicit gates: boundary values come from adjacent-slice intersections + x(1.0) # [2,5] + x(2.0) # [6,8] + x(3.0) # [6,9] + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,3}, 1.0, false); + SlicedTube x(td, Interval()); + + x.set({1,5}, {0,1}); + x.set({2,8}, {1,2}); + x.set({6,9}, {2,3}); + + Interval y0 = x(0.5); // [1,5] + Interval y1 = x(1.5); // [2,8] + Interval y2 = x({0,3}); // [1,9] + Interval y3 = x(-1.0); // [-oo,oo] + + // No explicit gates: boundary values come from adjacent-slice intersections + Interval y4 = x(1.0); // [2,5] + Interval y5 = x(2.0); // [6,8] + Interval y6 = x(3.0); // [6,9] + + +Inversion +--------- + +The inversion of a sliced tube :math:`[x](\cdot)`, denoted :math:`[x]^{-1}([y])`, is defined by + +.. math:: + + [x]^{-1}([y]) + = + \left\{\, t \mid [x](t)\cap [y]\neq\varnothing \,\right\} + = + \bigcup_{y\in [y]} \left\{\, t \mid y\in [x](t) \,\right\}. + +It is illustrated by the figure below. Intuitively, the inversion returns the set of time values whose image under :math:`[x](\cdot)` intersects the target set :math:`[y]`. + +Depending on the overload, the ``invert()`` methods + +* ``invert(y, t=[...])`` +* ``invert(y, v_t, t=[...])`` +* ``invert(y, v, t=[...])`` +* ``invert(y, v_t, v, t=[...])`` + +return either: + +* one interval enclosing the union of all preimages, +* or the different connected components of the inversion in a vector of :class:`~codac.Interval` objects. + +When a derivative tube ``v`` is provided, Codac uses derivative information slice by slice in order to compute sharper inverse images. + +The following example computes the different connected components of the inversion :math:`[x]^{-1}([0,0.2])` over a temporal subdomain, and then draws their projections in red. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + v_t = [] + y = Interval(0,0.2) + x.invert(y,v_t) + + for t in v_t: + z = cart_prod(t,y) + DefaultFigure.draw_box(z, Color.red()) + + .. group-tab:: C++ + + .. code-block:: c++ + + std::vector v_t; + Interval y(0,0.2); + x.invert(y, v_t); + + for(const auto& t : v_t) + { + IntervalVector z = cart_prod(t,y); + DefaultFigure::draw_box(z, Color::red()); + } + +.. figure:: inversion_example.png + :width: 70% + + Example of tube inversion for a given tube :math:`[x](\cdot)`. The red boxes correspond to the connected components of :math:`[x]^{-1}([0,0.2])`. + +.. doxygengroup:: codac2_slicedtube_inversion + :project: codac + + +Integration and primitives +-------------------------- + +Reliable integral computations are available on tubes. + +.. figure:: tube_integ_inf.png + :width: 70% + + Hatched part depicts :math:`\int_{a}^{b}x^-(\tau)d\tau`, the lower bound of :math:`\int_{a}^{b}[x](\tau)d\tau`. + +The computation is reliable because it stands on the tube's slices. The result is an outer approximation of the integral of the tube represented by these slices: + +.. figure:: tube_lb_integral_slices.png + :width: 70% + + Outer approximation of the lower bound of :math:`\int_{a}^{b}[x](\tau)d\tau`. + + +.. doxygengroup:: codac2_slicedtube_integrals + :project: codac + + +Inflation, extraction, and algebraic helpers +-------------------------------------------- + +A sliced tube can be inflated either by a constant radius or by a time-varying +sampled radius. Inflation is performed in place. + + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + x.inflate(0.2) # constant inflation + + rad = SampledTraj() + rad.set(0.1, 0.0) + rad.set(0.3, 1.0) + rad.set(0.2, 2.0) + x.inflate(rad) # time-varying inflation radius + + .. group-tab:: C++ + + .. code-block:: c++ + + x.inflate(0.2); # constant inflation + + SampledTraj rad; + rad.set(0.1, 0.0); + rad.set(0.3, 1.0); + rad.set(0.2, 2.0); + x.inflate(rad); # time-varying inflation radius + +For vector-valued tubes, the API also provides convenient extraction operators: + +* ``x[i]`` returns the :math:`i`-th scalar component as a + :class:`~codac.SlicedTube`, +* ``x.subvector(i,j)`` returns a subvector tube. + +The extracted tubes keep the same temporal partition as the original one. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + # Component and subvector extraction + x0 = x[0] + x12 = x.subvector(1,2) + + .. group-tab:: C++ + + .. code-block:: c++ + + // Component and subvector extraction + auto x0 = x[0]; // type: SlicedTube + auto x12 = x.subvector(1,2); // type: SlicedTube + + +Involving a tube in an analytic expression +------------------------------------------ + +The method ``.as_function()`` wraps a sliced tube as an analytic operator so that it can be embedded inside analytic expressions. This is a convenient bridge between the tube API and the analytic-expression API, see :ref:`the section on temporal operators ` for its use. \ No newline at end of file diff --git a/doc/manual/manual/tubes/tdomain.rst b/doc/manual/manual/tubes/tdomain.rst new file mode 100644 index 000000000..e02765956 --- /dev/null +++ b/doc/manual/manual/tubes/tdomain.rst @@ -0,0 +1,238 @@ +.. _sec-domains-tdomain: + +The TDomain class +================= + + Main author: `Simon Rohou `_ + +A :class:`~codac.TDomain` is the temporal partition shared by one or more sliced tubes. +It stores an ordered list of :class:`~codac.TSlice` objects. Each stored element is either + +* a non-degenerate temporal slice :math:`[t_i,t_{i+1}]`, or +* a degenerate temporal slice :math:`[t_i,t_i]`, called a *gate*. + +Gates are optional. When they are explicitly represented, the partition may alternate between +``gate / slice / gate / slice / ...``. This is the structure created by +``create_tdomain(t0_tf, dt, True)``. + +Although optional, gates are useful when one needs to represent tube values explicitly at specific time instants. This is particularly relevant for guaranteed integration. + +Creating temporal domains +------------------------- + +A temporal domain can be created in three common ways: + +* from the default constructor helper ``create_tdomain()``; +* from a single time interval ``create_tdomain([t0,tf])``; +* from a sampled interval ``create_tdomain([t0,tf], dt, with_gates)``. + +The following examples show the expected structures for the sampled cases above, both with and without gates. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td0 = create_tdomain() # one unbounded slice [-oo,oo] + td1 = create_tdomain([0,1]) # one slice [0,1] + td2 = create_tdomain([0,1], 0.5, False) # [0,0.5],[0.5,1] + td3 = create_tdomain([0,1], 0.5, True) # [0],[0,0.5],[0.5],[0.5,1],[1] + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td0 = create_tdomain(); // one unbounded slice [-oo,oo] + auto td1 = create_tdomain({0,1}); // one slice [0,1] + auto td2 = create_tdomain({0,1}, 0.5, false); // [0,0.5],[0.5,1] + auto td3 = create_tdomain({0,1}, 0.5, true); // [0],[0,0.5],[0.5],[0.5,1],[1] + +Inspecting the partition +------------------------ + +A temporal domain exposes: + +* its global time interval ``t0_tf()``, +* the number of stored temporal elements ``nb_tslices()``, +* the number of attached tubes ``nb_tubes()``, +* the temporal slice containing a given time ``tslice(t)``, +* and a vector copy of the stored temporal slices ``tslices_vector()``. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,1], 0.5, True) + + td.t0_tf() # [0,1] + td.nb_tslices() # 5 + td.nb_tubes() # 0 initially + + td.tslice(0.0) # [0] + td.tslice(0.1) # [0,0.5] + td.tslice(0.5) # [0.5] + td.tslice(0.6) # [0.5,1] + td.tslice(1.0) # [1] + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,1}, 0.5, true); // returns a std::shared_ptr + + Interval dom = td->t0_tf(); // [0,1] + size_t n = td->nb_tslices(); // 5 + size_t m = td->nb_tubes(); // 0 initially + + auto it = td->tslice(0.0); // [0] + auto it = td->tslice(0.1); // [0,0.5] + auto it = td->tslice(0.5); // [0.5] + auto it = td->tslice(0.6); // [0.5,1] + auto it = td->tslice(1.0); // [1] + + +Note that ``tslice(t)`` returns the gate when ``t`` matches an explicit gate, and +otherwise returns the unique non-degenerate slice containing ``t``. + +Sampling and refinement +----------------------- + +The temporal partition can be refined dynamically with: + +* ``sample(t, with_gate=False)`` for one time value, +* ``sample([ta,tb], dt, with_gates=False)`` for repeated sampling over an interval. + +Sampling can occur: + +* inside the current domain, which splits an existing slice; +* outside the current domain, which extends the partition; +* with gates, which inserts a degenerate temporal slice at the sampling time. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain() + td.sample(1.0, False) # [-oo,1][1,oo] + td.sample(10.0, True) # [-oo,1],[1,10],[10],[10,oo] + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain(); // returns a std::shared_ptr + td->sample(1., false); // [-oo,1],[1,oo] + td->sample(10., true); // [-oo,1],[1,10],[10],[10,oo] + +One important implementation detail is that refinement preserves the attached tubes by cloning the +corresponding slice objects onto the new temporal elements. The new slices are then reattached to +the newly inserted ``TSlice`` iterators. + +Shared refinement across several tubes +-------------------------------------- + +One practical consequence of the shared-``TDomain`` design is that refining the time +partition from one tube automatically updates the slice structure seen by all the +other tubes attached to the same temporal domain. +The following code illustrates this effect: + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,2], 1.0, False) # False: without gates + + x = SlicedTube(td, Interval(0,1)) + v = SlicedTube(td, Interval(-1,1)) + + print(x) # outputs [0,2]↦[0,1], 2 slices + print(v) # outputs [0,2]↦[0,1], 2 slices + + td.nb_tslices() # 2: [0,1],[1,2] + x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 + td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + print(x) # outputs [0,2]↦[-1,1], 4 slices + print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,2}, 1.0, false); // false: without gates + + SlicedTube x(td, Interval(0,1)); + SlicedTube v(td, Interval(-1,1)); + + cout << x << endl; // outputs [0,2]↦[0,1], 2 slices + cout << v << endl; // outputs [0,2]↦[0,1], 2 slices + + td->nb_tslices(); // 2: [0,1],[1,2] + x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 + td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices + cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + +.. note:: + + This behavior is intentional: it keeps all related tubes on a consistent shared + temporal support, which greatly simplifies multi-tube operations such as + arithmetic combinations and contractions. + +Gates +----- + +Explicit gates are useful when you want to represent endpoint values separately from the interior +codomain of a slice. The current API provides: + +* ``all_gates_defined()`` to detect a fully gate-augmented partition, +* ``delete_gates()`` to remove all explicit gates. + +Therefore, a :math:`t`-domain built from ``create_tdomain([0,1], 0.5, True)`` contains five temporal elements and is a +typical example of a gate-augmented partition. +In this implementation, a gate is not a separate data type: it is simply a degenerate +:class:`~codac.TSlice`, i.e., an interval :math:`[t,t]`. + +Shared temporal structure +------------------------- + +A :class:`~codac.TDomain` is shared by all sliced tubes built from it. +As a consequence, structural operations such as ``truncate(...)`` affect all +attached tubes, and the number of attached tubes can be queried with +``nb_tubes()``. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: py + + td = create_tdomain([0,3], 1.0, False) + x = SlicedTube(td, Interval(0,1)) + + td.nb_tubes() # 1 + td.truncate([0.5,2.5]) + + print(td.t0_tf()) # [0.5,2.5] + print(x) # x now uses the truncated shared partition + + .. group-tab:: C++ + + .. code-block:: c++ + + auto td = create_tdomain({0,3}, 1.0, false); + SlicedTube x(td, Interval(0,1)); + + std::cout << td->nb_tubes() << std::endl; // 1 + td->truncate({0.5,2.5}); + + std::cout << td->t0_tf() << std::endl; // [0.5,2.5] + std::cout << x << std::endl; // x now uses the truncated shared partition \ No newline at end of file diff --git a/doc/manual/manual/tubes/tube_integ_inf.png b/doc/manual/manual/tubes/tube_integ_inf.png new file mode 100644 index 0000000000000000000000000000000000000000..c21d66e8aa4f53563e58da3a776e54b6b4a1ddca GIT binary patch literal 160142 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%0D)@a{B%@s~Z`Q}fol+L;lZ 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%0AsTq(qH z1I>t`-G}s}yIE!*hCXq?Z5skM8-&OtLxA+O zm55*YJe;nt)u>*Oh@1@^4J|sFEaSt(sYE-;W1R*{_B8TmF-RG7U@eHo4S9+H2t8TV zR!K_umjPpJo)DhyDE}?Cgt^o-wugsmvHszaz7mX2&i}rD{`Xl4$btN-_>*)rmAqfn zerHWSJ0VFOk%n%B>5J?7IeNoFh-#@_t5I*2k{!srGoEt-s<3yacgsaeMD^h;AFg+I zEJ^^N>QzeOE>bAUmq0Hxb`0~NIFVkVEn%hASIwL6#PgLR8HdCr8Tvtc@18wvbH8gU zzFoCb$Gi@x<;GZp@9@}#kB4d$6Z2_3Z%k>;hvA&ZZ+(nHDB*8<_^OCbxt)|zPUk@CVOaO zwQSZbsl)ZJXt7z_jNsmDx9OfSMV4116vxbtFDMz99TvN()N!xt@$zFVF zb=A5{JWIS<{9bbq63;t9hUUT6q;aSPKaPfX2T6IU;f13I{mfzy6t$hgN=A^7R7$<= z+6h}Pek}|(G}A|rA3AoWB&kPfo>Q%p-iev75+%IAH4GzcShO+Oz?o!rjXR`t3T$C@ z;!+6Lw6XKd%-@LDCQhi$yLUG={-&73h)D_PC6J5=K+0*sFh1fzY{&Ygzz?w#HEP`0 zA+SK_MlHpoRDyKvP}5L*V+Y6^&a0)pef*I5kK%?=bVz-L8k9h^i2|rRdGR6xL)`#e z?1X|ktZEz-G;tl+J^Kx&Lk4ZE5z?OSF?QlWn5oPmd$us?NoRB<+a0XDOMaiIl%p9Blb;!IqQ#VCsP9iGVSI3 zvaarg!UAQ=Il%=Yu3|wYb*!QMH*P<{60W5*UQb2?@D0KlW2*0>0@`lhRcN<6uU$&{dM%;9SnW9cwz579+8&Qj-iJ^u<=+_wnJ@ z>C7q0paDpabbJ}1E0f6Es&nU!l4>xB%9AA3kVmP(WYCV-rD!IR;00yPx_TX%_B19a z4Vw2OE<+j5Vcd1@eyRTJDiLRb%*wmkYbcO2M&eC0$>s<7hJ9yOTj>qf~{kl#ddB!wH(S=vIMEIOyFgwj$)Gn-z(-x29+v&V;m%D zdHEFS(G)W@_MK4nW~hrAYA?#QLashFFwvHmG1 z>HX;X^;dJ-@V*lUxA)#5w8R}QG9A`ZW)ZKC-58B{52#i7)Akc?NuRf1 z5DLY|cajf}WgLOT77~M+H^RDu3cWGsm{H6mmIxj4W|D1?_sQ@%rTON&MjVrAV&Ben zucRu@HiyzmfI9dMpCV%apx7c5diU(9eOfb@smHt?P%V{tIEDDwcCQ~fw-2oV7LBY2Lj(vXDM~H*sRcnJmTgW{ z9Ep~Zu(IY52uQCNJZmy}I>Sp64I`r38L#Y2LjhJMhSJUu*@y2DUbmLX;dW#HvNSh$ zp;Q=zEeceq7Pv0siT?TGuF$&DJP8?~at(M-DfRJkyQ?ACHl^~H@1_D4<+gieMN{zh zk}cTCxvbTC5mgy7pe~wm5EFV{K~-FDIQe)AFv?DK#?=cOkvx9Z+J`7}Yb?3ZLj8no z4QCKv#SOKv;xoo95js2>(>v*Vw}@tb`^Kyku9OdDA15Srn!ddjGbPv}aMJx`)({Yd zm{H^AB2DYd@cGMEpV>ByDw<_F9l@kEfz)$ZP_> zx8TgBL4iDoajdtLIdE};+D##yt~!2D-Q26G)DZ!T?*OM&G;8m_T@+MNcOl2t(N>91 zZY%8ddGbw1n;I~*-xysqljMIwuGwq5O78tR-zeu2-R)y9%_3QHJU7gqNrq7FZxJ8D zaIrOfm`ssj(d)(FxIk8;<-ecG_Q5;-|GWU4^5kSwNmopGGt>6(38$9{FB6J2PS{;O zP)?&^QZrHpAng_LK*lrRAL~T~9U3Tv`9Iw?i&%VVMq#+da%9u$OAKT*6k^^@$Xt|N zS3Sk@5jWbBw}=VI28|L5lg^`A?4R<;1xYN@Fv18eq!13TE})G)+KMI(IY6q*TZ%%k znrFpt*|M7&e@aW$|GqgZG6ZD?FLE)S2bn)n5Lw)j=p>dVqjqD?KX|akRPi_^)vpw8 zj3AK|y_R-JkaA0uO}3tvhDjWH+&IL089Xld2~uo&bt7MKN0%X4N%=KLrKw!5rPetY zJCiYGD9HhasZwuUIDLAtO?GE=$h8be{*A^hA4%0qgS zAdp5V8MuR>#QY%!P`83;D$Pq3CR}Rl_?BLWx1*KrRBH>ihBE(&T_w;E>CthJe*#By zyC85(+B`3F9VLFs{|^GVR{*sbv|6`b>8$b>0#y8(GHjL=l@X8BJ7y|(70;KU7a}`| zXNZy?M#iQ_dkdQ;bYHbu;4_KTWIvwx^N{T9JS`M?ME93}s49;w9KalTO;Ht35nD*D{$p z9*Z-TeipVxMyKG?jbyE1Osf=z6&Ni5KLq(#%wZ!J{+t=8e0juSWBVo`niXTDmlO$&)LgZ5 zFm@j4$mXmMsH~zmdaB%-M9L^`3W~4yP4|a^{i@`8QJshbLn;iu7*yX(I9d_uDbus? z-^ebGUA_7yEjLU_IaNb1@)%ls0xd~YOk&RA42cDVw+zH;mUX{bC=#jg2l(v&klS1I zTZ11|QX8xAV3GUah0Tbxixj8o4s0)nkU}RJk|@Vi=5vUKkK4LHdFuo#N9mHmH(l_z zkuj@0&4m@Ev-9r!{4%?9(AgDnt5?^C(r4}Tr5O~ zLG+WxkzyzZ)I~Z=wFW^E0~xaqwi3MHwfa5zEsO;oK!-8igEIwbC$}=1h$mx<=zxgT$Xd^MEh(Bn5L@ZxXPl5U zRh?44WYCoWtYc)-4QfeQvg)&9s$};@t}m4NJY)$@h`TAtK?r@8g0eZugDfM>3k@3d zQu&hk2guto#Lp&%3fNNtN-EdLYBclolsl(=Ig5lTtMqsHFEb6LFYhNvmmr5GGGRuw zh_x*#7!e9f^mTYXZf;s;{xgNzlt4)^0Z#ml1A)S6pje#>G)%I^KEMz*lzi#@B4dY@ zspZ9}rqd(4Kud`FNncxU@ohRQ$xEmP=|W%^hT(FIUFDcz7qPhi*MZ^agVC@4YMF%i3mR0iQ!9uwd;|H9HFefMCG5$y*d?*yP zC>>$~^zhIdwQx{r^J3e>UHnf$>314jeO{MY9(dGFPq?<(1$onDNJ_*|4Da=DXSY zzhArdx3}iuugXK@lTpW;#yea3ccYO@Uf&_3xSs9ptwbz6<^N>LtPjKLE_S9|$Q*I3 zy=}xXy?XToVs^#7RiH!|Sa3@O8_MbRYGoEypNSk4e!_XHeQDM*a7&IjOb?WTGwY80 zHcwNTesJpJo`^vq$nL+>y`zm|4K0trk1vb+(p@%a%$Vk~@EIeH9Yp34GZeV2I_&u+ zMr6X0*R=H?#QMq0S$g#Bi7GN?F1>Ns$?|rXd*+pk__k|~+1hBS-X{SU)k#|AHYXl;}l*{(J z_r-A4WrwSie>B=q<6c9M0DC7Ls!gh4B95MT?m-ny-fPY|m)*{eKF|DSxiK_Rohti& z7)_x$Nv8e)L-c%TnY?x-( zBVs~?=4s~F5<41a>dQnfTW~&!QL;b*C1sX)lCb}&BM+Jftp9E*EMYWF!?sb%i>nC} zXFpuTGSY!PHPA3wONdh_7N4+^Qh19E<(wq5mx@ih=66%sj2d7kWlH~7UPVCKsgBMwX z@}mb3TI1hp&hj@0^1sJi-rIumg=UX$=pM{GN+;!Hfw-1v?2KSt@L+a4+87tl|6*FT zG5ETLK4IQ*e-$6hDH6X2*M9p}`JHZxO#*HMQf+@2n7H-p8#wzLh%H276CxGxV*uGV z{8zP|9#Y)mk)W?Q3$lk}e6P-y9#t%h#QX*u-l|or<%Wt!6^4?X=ZzwF4^1XwBzed^ zW2c-|mS^#A^m!#d?>Yk=Q>4ry52{=>T1lreL@`rZ*KWo4@#VKfht1wZ#*wFO-yRC? zm6PjF=#p}o{(C31?i3Vg@s}djN=JZ>$zedPyu^fNQE%=;j#W@iryP*j3qU4WA5KM? zy>k5x4a@gp$${`0hZ9fz(Rkb$_ILoU8xGsX3=0^ic04DnAWu_N6=Madn{lAjMA=gSVQLSM8mlV(AbA3KFO;d4NemzP zig}{Nw7IqF(4m7wcpA0*^>j;W!(XVo*+!4H$bHCyJ8*i>^>}oCcu9&cCr}VIv^JU6 z`W}t{TgjRI3`pM# zJ^b7I6x+&4i5TZF@s2m`r?48$v@5SucR0`_dV+3L2^^9OITskN465bLA6J+h32UGF z`)N(-1!~UjEIFH6irI@*3F%caZ*Sn3O5Z5|87l+*)lamt5dQf9#jdpOi`E01x|`%K zmdXN+@;pft_+4*6fUuYqedV$n%UiazwL>|qgp(Q_K+?N|swu0T5GPK4f7^w~zQxco z5&9mS5AQhj=z^a|;4lHdE-ACIPuk2};bUW2hC1e>@ zQLIK%9uHegDl+f%H$PM;MZ|8X3E3)*1wGCseGDNMLxIb($ot9g(wS;0Nl7$J)2O_IEn={B34IKO znEO78oe%z2LLX;xjFeSE@e^%1lNF6=hT6F$-`|6z4h$JZZAXgsj}&r*#6T05XwMR@ z$WA6^?nzLR>e0#H-yHfx%_n{^QMo5fsPHjRJ|G5XNs-c{2Scgg3nCtt47FBzi@|`Z zV%u-emh~FG@3+TD(*I}RxpZm}DZ1ObM^M>_<%#Mb0VAWlql)e--pjD6qjGs9>%uFZ zQdt6WaCt-aNy#smx*kkm_MSG)j=)z1>nZ)^Cp{M|=q7Ox0Z7;k>5eYQ_9xUMlI@o+ zApB|)YQe9AH`oQoXy&Cdoyki$WRjjN&9Cl<@JUy0#o#BtCb*|gepMCgHRM@I_0&bH z;L!u6%MzU`4KY&h^eL=)p)&cEh70MW;tzZf&;<}pReZNms%DU_X^SG#B^zoEQYsQa zofkO4qqb{CMDc2^rvliuK#uizCE(F z9`KvAr~kF3E08gQUJb+ByPMp12z ziP8BTPpo?r9%ir_2&{#)>D+7_FAT)N?Yt%(qkJCU?zIHtZ#P+UbP1cn*=+=cMVoPvDw2PNPwDG`Sm#j zi=&HU6_A0{P2=~R*bY>C#VZs<-2+DTYNQP2?L6P6F^Cz=q4o>Nq73Xve;IpqW0%>x zSM+SkH@ZNz_GQ@ao#S)baZ(B-2GgS5ZuqOv`=8MZFtk}R{FD>fT-(1nbeE)Tp^Dg?AkZ3cpguI4z2chH z{yh#n`!ADX)T(vs{v;@^IXVP$p`I~$3GR6N_N|*nM0X~rrHJbc*>o_}3&rQ)=*Fqa zlxigS?Np#;ByHT2zB*7=)PIqC?knXw*U^>veMS>#+L~n30V3WM@hqc&$Z&5PRn>?t zCAjA~deW}LGiz1A_I~R@+7O|XO)tl$M9%mOIfr85E7j=4h;4z^!pTwLT$db70M^%5 z-nt-Zh;x?FtZLQnKVaY5Js{xGub_8-X$D?y(mf(~?DlJo8~1kaZ511DFzm>*{i|kv zzQ6Xy?w~j3uX_7__HVs+{OmV-W89j3+5J7y{cWpWlQMM765a+aSXlAw(D#Y2+mG8m z_T|rSH3oM5;P~$O2HSS;o_`Im{M_8#%d3ugTulCTPwJB%E-qET-AYc<&3HZi>LdE} zsZP_@6k2j_-MVF?XKvmM^%2!n7Ox2*&ZQ8C~9XzF{afz)-OpJzEc?{0A>CmAUF0u!gvrcz$_qp`=-0Gb0 zuhZ~Kizi#PB&K%>pdy;43)4=WHq5@Rr{D56`0>%>$BX&?@>7NGfawBA>>SW2Cq0G7 zRrvScK{jq~#g^9ADwg{+67*G@n3$J3^;2COEv?-WGI#D&F*@P!+)q}hLCdaP^SpKU z?&&*sj0X=M%=PTK(RLtRi&MUTo=DMIN^9i#3l~HYc~n-W)3IN1goCgz zUD*Wr|84@$d$|jnpo*L&o(6=3=s-naZr4vtOmx4$iUB)K&CE35+?=LPwMEC#0y>9` zAOFF$I=X~D?AsE`AQk$!des(GejN*Ar$M=)S{&2+g1ooP!otFo(k0-$X@dLI&##B_ zCf)qJJOzf>6^oaVNH%uMRmPt^t8t|s3;BHrl5x|QAD z*McjsNXnYTyVX__JWIeavad;s{vjdfHCuR4=%3-a=o=VRad2>8`&jtnK+HaPu&2Ab z?$X8<=AL`$E%){FlPqszYa3v?FfKlR3CRl$C>8w&v%G^V>$MgjSOTqani7R=e1R<; z+Ueg%nKfeW+|F>6tMDA{pZw5-sGfb`K)u)H`!P>IIoAeWRv{4MWnDVmNB26=+JEfW zrI0T2m?9f8<(incg!mH^AX^I-r3i;!zb%d%0+g_dax=*F_a*t7Ve{sl2CMwNLr=dr zf=l!rIy8W)nUzgX3^KDSSbWN5|DA2yw+9lUZvp4}_3P(P?ON95E0kd6=c-KVZ$lhh zNgm3-a-}BH&hvWXt9&RuQ{x9%QeJpdlpWxzUL^Q~bKL0^CICk}yKNiI!8GK+QcAv@ zQHx>B1supJ@YWJmh{(({FHnM&4Fd`Mw z()vf|nYvP=o4UEVGX{Do@?qYUE4%)BGtb#sLvD~#F~7LD9_7-K#Kigob-#Bfo_t1I5a z!~SUbO3DBGp5cj2n+DGvF*K@&PXFVppU;V^mpCpXBmY^j?%*~f{<-0@{~kPRc4)Dc zp^;Gl=dtkS&F9VyA~@Ux6JAzQoA;{7$;e|;Zw$O}Al5PU$-s3!~m~PsI5a!rvv#A_u1I&C~&JXc{UOn z$-Ho3&CF9WXfdNCRHM)C5vsJ5{HcZj89(mkQwgVcn4N(3;Yb(VdRtsL{G#YYA zNl9M7%Gek!Yg1DNZtmRrQ41~{xf2r;KYp1&uBdWXPJ$qK$2A$2j ze0fC+4gEM}!=_EA3ktMwYnFffIGP7~AU;Wdja93bE%U)BIRJ;USFax9=#X4xHT;Ut z?LA#CT`D|%VW3sFp$}42^FLbUp4$75-Ts_a;ZHYg+-QtIxC#N-pU`+~|F}BX^5)oG z&t}0=(HC#wemHGvZeRnfD0}(R+{`Re4%`M}BDLu%9^H+XKaWp;UQ19naVdadABI$J zmpnM8uO6J}Qu*VdPG+yBqY@1 z-5)BV&W|4-s;78l{^td_Dv4^~GUN8}a!4)acqX}s>bEF!^-N6uGUXWMVQ7NF0|6+IZj|Y z$t~V83cV~jWi3|hN2I#LIK_9}mNdO&>Czw=2DW4YJnf^GFLiU0Mjg@9&sa;^0nb(X z>+uxpKHR*{ovE<}IMI@~Ze2`KeCqb?ubXdXWCoXw0y73txl-0@?irmGKvh*mY1Az| zN!CH;c9oQtE@D>2I`zZxwLZ(cy=V|KPI$PUB#v{t2|k0iYc_3KPO%#{XO6S0>*8t~ zV|rJm1I3gBOsyg@vHgPj0b1L1VMX-o*N>*Q2|_e5>^j$e|Ni|C=A1Z?qG~;M^5oU@ zaO;v*Ps8QTxprMIuJ;n$M)Goou&@6#(=;0UV&9%D&{a^4^m7-)_-6)7R_;ln2AKl+6IFb{%5EScZDQzs*^kvc^Ln7J?V@${6Ht-~aX zB%6RLsFf+ZcaLoSYWGTZ2m>0!Ar=nL`_hK!aiLB|G-O!~lBo+{BIm}GJ)|;mG{k`* zpQydUq^mIv^;Y{%)HZR)Ji|q4Y0YX|=nrbWb^CU0S_vLBb9eKuk)zkl zdG3!2TcW};y5J-zK6r5Q&W#b9E)`B=`5-uIy?vN_^=naROmwuic5Ratd?dqM+5vDi zO0$o+xjF10Ez31h9=0ia6HektY&&WdxKh9qx{~A$4GZ(kGmL{ApO6xC|hJ;u|8*cv-KX1iJ>3=1b*V9uZ^ z>ikPQlz9HACPE*=XPqaXd4HRkm6a~vojzob3AIENuX3wx5WA$>YEtvx*RQ)#N915M zRi~b8y=M8A1UQ7~DbR78qH2&%SvNl2bThh>9?h2M+_`fF3d7WQ54tw$I3=RR(3*z4 zZyw8d3?>mfFoOo3%f}?>83IMmwHFi)KU%)6rwbNTTjR35=w}tt<~6kz07Fa9G>AU!J-5>QxQD(^(=M z?}IUuC1aK(o$fF__?-Jn z>O9km1zXP1I(_b3wQt|PIeLKS)@<2gf?-Q;UKXTpwqBa?><`cS|6sU77;38x-BTgs z#`$~?y0>6M(_3~Q-R`t|eSGV!W7TS^ROJ9x^XAR9;k}>t*)f{GZo*>dH*6@6MQb~P zUiP6w=OAXKvZ*P@ooaaejD~pn7vpIO1Y^o#Vk*$Y!e`QmwfXDxX-z0BHy*F7O;z6* z&y^&O)6_DwevL||hY+}_JLiuUN2=DV>~C%m5S`V3CA(%oi8mM%oGeBJ$I_gx z%}1^V)Fq`jos#Uw8DJ@}ng4CZ$5%INZ``=iQOC{A!VBKJ{AF>gRR?<#eK>h(QWL}3 z6u~rf81mTa(~>=eN9oYy(e?byh)o3qW|7`4COdsorp!UN-n z&=g_>_x9LP$9)@RELbrBn9Vs30JT&(6)>HMyNZ}``O1|Xz*tn*v+On--c3+&?pzR( zLHVaoQIU}vr(2k(F0?R+E#ysH67IR1jE?nFx7kw)R`5bITg3E=@84am2UouMa%5}5 z@ZgZ1BhAJXSd`|h=+xW6BJjvN)yjqK#-{H-ySmrc1`0gK;|m#X5HbQ1r?lc)P-HqB z5C3XF={|ka>(f%oQljsQCf!Zgu6yDpmQ60!nm=sg;BU|WeA*!J*?YHbmy+6fn;Sgt^5x*P zhek&$W~{y3$@P=N_4qAIdt11W98J0}SOIbM-ohu9uo?s^`y*>rOm8PQbA22wIVjc= z0W=xQpx2l*_h9t3|!kVxt}uRUWo&Ek3++Ue{2Y=8j4 zgu4PCIQO|Nm8g5FcbezxI|pj;Dg;UUMF1q@yNS(@`XyA}UTEdo5d7We(5#R#9$$|P z{FR~lWZxlw{fIkG{fAEXXt=x3 zDwo~Z`)l?Q8VRTUnnYk@VDFOHIxWnprl`?+FNODXxhBplt-N3`6Q~`z784hBl9qnC!BY<6L^WcK0P5 z5Y1-hsi99FJ&HsrwbL;-uXn~JK63+L!68RzF*<$wHZwf+ z*SM!S#wFxkyJmo+AZFDn+51(5qM_V<1UgV7mT)|b30wSR8APh3=&y#YM|L?Fs;@=2RpG3fQN9@GV-VeUDL-+FK^~y44n^yQnpob7q zZkw8$N4>h1R)a$J3dMl8UX4MS?J?#1(%?oL(+V_uXPW+-9qiI{;Md@E--uw#^0|gL zDHI;l5GBB9U}&?#Yu8+O#(KuaLM%y1uc-6SGebi|$!E+)PS4(%oU9NZPr=NY)?aRm z-7;+MTo>~=n~vt@p1RaX_Yjtww7q9$ZXO`ZVBVoa0~*sBBD>l!e2JOWQ$vHF)HAQ> zc&RX#dpd<5e-*q0jUwew23J85C5s3As{ARZMu7;7BFmPLRn?C|z$2X7+;$1Q*lkcG zi}LcEguP&ghhf@EVSi@F#PrUvx3@2O{dxslfb8*lr(NP73`JfdSyabnzM@el1M|oR z3!YxQR5&9srQZJWH)~0agXv|?&D6E3#+~a@y*{rO&2C_8GC^!9j~3!3)wtyC+giYV zl3pp4G3uzcoDygl9a>ZvG~LbBoWJ$>*|TT~VO`q&`{jMU+8p5p(dVRbe$26<(Ur$A zE4d6C){vHjlGxo^u%YGUTgsX(?(l0)Y z1jPx{f-?-3^S30*(&zT5OCC6T5^hgQOi5^J5Gw_S@Mtu?KB~S)i~Dm54YgwLpCfyR z`tlG9F>x|yY=x9eg8+F9W@{x@N>u2u#;@**V;K=i`v0{vyCTB9K{0x)A z)+8iUZQZ){<;`7&thqaf{y{~)KuJvb=UQ>GR5|by{$s{yySln=`JrpU5r+!cIpSD- zn7%*i!~$$2Mmjn+f^!+oUFZ%bEW$Sj^7N<7oOuT3Y&l*oy3nf8F{EPqX`RW>*I4-D zeKll-fY8v3PFxWnV(nenjB=Wb9s_U~>yd~2ST*+w4wK@M(PwvbJzW}V<(lT1;lFR+ z!GmWp$l@)F63Q{qcCz&l3v4j70U03hpM^y;(g6Z8p5Y93`Z(^8 zFQlOdWc2h(R1!uTp}>a580g29^tLb%(vv2}(k~r&D2t*jFFb`1{qGQ>48gkl!*M7P zPhJmiH1L8`#)?JRbLKamaUeuz&fA0)eXr!bxjdv^}ob$$YU2H;-)e;lTH$XJj8a_92I3+1FvJ*BNSt za_V2Iq14b>s4o&_&Es@1k2v9ruRM4UD2qm1Al&Wb$yf6@KOVFxEy7)^Pw$?TCsNXa zIK0O_4Nhlv$%{rk>bpVEEHiKy{c z_iD|5-NRhJ+pizfg^{>(XJfO?i(ZtKCBtm_9+}omM2$Gz+Q<62ZF@_t3HwlvUY|l6^4=Bra zsA~>!oFe(xymw;WdXD3XtuV|2iv@XIzI@pR!IQo9zDZl<2mSFp&4s4jyZ@;n+fG0x zF>*AB+A3mp%(YzXaOa3kMW97h!}hNyU-F#(Px*)2!|WDbeVki0#WA=nNptL)%FMvq zgA?pNp8YW4b#B{vmUl8$>l$thYjSt;_KU;$gBh)8-U<8|o@L66 z8Bf-^MY6|Lc)I{>wFvfO0PGGH@Ra}qi42`qbkdJ&w9T_69@6w29?Ir`=0>+Jt3hwFm=}8;c$A52mbm+tE(QQ6}@FV&c5SQA_qb-c#CV(i!t3DFeD*o<6yTYyXw* zd)hvF)b2<4+k=fuX)>o7aDWlq=puvXjF4N1v&9MCjT`0#H_g5E5F(AQEC`WdQ|m#^6stQ4+R^< z=`5euCBNUmW7obLZ`v4Hug{A$A+MbN>3+%j;{pA9#ns2Z9jT>2FK-1^#;jOT0D7sF zlk~TKtJgjJ`qzZa?nN_$yu;~aPIL22Gx8Qh%UCmaw~uW>-=r`d(8{U1cN+o*7Ct}r z>e9nH;E^CG0M&+=OdmjviDOs<7Rhbfwu!3x^5sh#m_5i33W(&iv?$^NBN{|pBFvi>iS+U)_C?Uq3ycTzqgn@+5g&Zf9#g} ziSs&Lm_N4c?#05yPcz>;tqO{d8=|h25~q$0>FQA3f{)J})%xSi(Qn6- z$fq)qwNa;OTIgHhrItX3dOLUR(r?^&C8ipQ5ymC&-qmKbF3p2&*$#3*el_jVrJ-bF zUWi-BNVtk`-(33d`gU?!`G*f8iLQph4G9UcnPNV-1zGvfO4nMH*k za=-iCEB-F49y)JFFJGDSt)tbslYhk=vEHYen3@$uLFB*9XV10o-v-Xk zpF6buf>&$uIPDnCMf0l~o{h{x|_)dU*B(vqIe@uSMD z!-oy=3Z4PjJp%EvHX)Kx$cmTBKu zxHZQ9ko;HE38F{A?TT-J+DYMsnum`ZN#WonR8Csyy$Pa81UJ%6c^5ls$I_1LKX!o5 zae*O%JWPfc&UmOl%_!4rL62$U`lQ|5!PeQgA^gKuU182cLSh&fs|6KI_4BMw??}ob z%;!x?XhZ0gvEu7g>h<^kSNN5G3%tW14>V09VvH+@Qij(@#iu;Qm7@m@RUX@WlE|ew zLDe85Wki}VRt%>o6RPZ@$IulkR|;uiJ?x+gxRXcC{hnS-{zBxRk6$U^cowo0;Y5m! zWZ#%;0>|_CU2zzMgbtpxrN3+cn!v7_2ONs-?~NO7l&zY-%MRKbLQ60s4(vzkdgsH6 z1^D|%fL$S4Q;ltKj0^HcdE z*dzCOSi4nM^cpr?j!!9&vUl2uqPwY)yZtXo9iF^(dwceG4;#a z5#2V_oj}`$=*~cEsbSZS3k?lKj6B{2mUbs5eCwfmwV3TxLy#eL<5pUp-RFhRoHJ;~Hs;5DydpI;jZ#mzj7vKKFk%i8l66n}os#Nl@GK9AS;kFDPm zbRZtpW$6{-hh_cLnZrFj4QND=p52A@u0O|4Ro#&x=&qC>8?$Ti702d<@db!NCa$$1xt%Zjate(K*QF==qPwL;?}H*z)6}1%41(fV;}ZEbO_=@ zM_1Pc8>`6w=55-nYU)&M9vT`do|LwME!10KrZ+wb3e$4-(pI3L?p)W4c6HOc1Y0Ut zNFK`p;ldaqQQ_ug3ONtXoN}uthfq&XFM{*F6;o?~-k@F6DQv@e&5aZX_CdCqhtQ1v7zdnAAv7mvHN|N!Pjlcp4AScwrz4+n2-xFyA%s z)A`P*qhDQBqo}hb9wDkwsUVA(=@sP|ZFi}#XJ>2IUl+P3q@37zX-M?oXA}QeyjYVL zHmw$+a$x(auZpu8pj@ryYv@kPLa*{%#Iy9`lI3^jUO;Q z|ejPiFWKhC_@je9ec&LvgNn(tYoM?7N3>;q3exZuW` z!h8ytMGI4Fw^vET%$>uJ7+{;plR1`a&Uwr-I$F5zb9{=Y!_2hAl*j=IZCx*I^K5i{ z{m6_zKYjUfjwrV#KE9yE<|+(f58_$D6Ze2yp+@vf{a5xp;KJ@k0dtq^28GqiqcI^~X z8=~0>`_jF##T&sU`j_c*mrgYCJ#diDuK$k&S={RZ$Rm61D|AeWuR-^T|AF5=H0V(i7=R&10WF z99}qRQ}p?tEf8si?Z*iz-UKA-52HPt@nnc?fVu3Fc$I9uT~CGc!K@1PA+)X8YTHk@ z&V;sdo$Pq^Y{BUUnY&ac*2aDMR@=_cY2fra{bubBclL#DXxXdnkYPr1ANOeAyiw;- z6Q@Tl3p5s3k-MrZV`n=KLwdwWeVoh1_^=X5oO`C#* zXTN!KkJtA-yLYbwC7h;eqZBEPdS>-)PClGFo-jEI3P&Lj1CLaeCx86YH|k2(nu?Fj zCOKZsD1T>A^lFjE1G^b>F9(lqF!=b(E8atDEI)P-^>4)duO_>@URryk--Cc@eJ@_L z8S|^ty}5BC0*3lrDtytaZPOj;+fMDxj8AFR_Wqge+v>(&@D(QG^2vRNH-F76omy|m z#KTW{-BAhUs*v7)Ch2hM)WUxXXs` zFYlk)@BTa%!Il>~)R}N+f9xp3Ry@;&1%bBksX`jZ=Uu$0i_=tmf?x>e!?>Q{bQYuE z2QclR0z)9`^J%{mSD_85j-TYW$ZW>U@EFYCfxH^43>9hfRaXmxM?lX=TG`|^1)kn# zm_VrmzkZI1cZS+=YsD>s$MzhGT@JjSw##IWMARhgn({?_VaWCLxM>f!X&@i^bsHNp zV9=S=egj<_o85nMterjen9G2N5j!>39kqAZeeI8w7EQXYe;-}fXJb42jy*r0tm1TH z#nNe4jgCI~SaZW^*CU%Yo$orf?ApE#Q#=2Ry8LwCz1M}QCnqIbt;snNh%W^FI`8}@ z@#u}&1Y=%dyo8dvrL&Wh0`5ySULO}1$+QF`n&F)3U$n)Du%G_D0k4n2hOu%>;jp*p zxLLJn-@ZQYqCWdar|E?t1nqy;U;PF@KyOsdrB{8NX)5A$@-f@nu;1xbJ@zmOPHNd#*}|>5+8zcCEA1>MnUd?rL_$ z36>&)>76GHKc@!k}Q$zTiKUX)+{Y5l~SqR zK}J>?%KOt(emi%tDcn2zqA0Z?3?L5aNT%u zhPUQcFb*O3V31Z`*lRYQzG)L?o@tO$+fzXbrOW53si)XCpFu3*?9fky>K4*CR4yW1 zTwH_!Lz5yd82)Y-7n8|^Zm$~X^3%nEJM?z`M{NRdtps!A@@C6AQSAid7(GF^S@;>BMdJwaUI1y<{Fd0p4b=uP0RCaqEkQg!yNJh)oWw&;SY=6f5{ zw*x^|BQ+LeKw6suahEbvdKz z8#iq5fAVB2*iWMa2O6dCaKLdwh%W@A5)O~|CMpNiDRw~naQemFEGQ5nxIG$LbXyoG z5RA(WEJ?P$Bc0Jw*X+~lxMI+&h$yoXGQ?5aaUMl5uf2{$nfWfsymU^uy!uL=_ z%?w7|1x-vitDpaSm24pq(li4fM=&9q;8 z9VgQ7@_%_o`?cON>#-;EuQ5&SL9E!TW+6}0F(3~oW@k>Q`~8aBYcrn?q^`7d3z@iu z(^9Cpsc9kh$gh`{QeY<50nNiWPBG*JEQFw#+zJ~M740{iwxR;1rvM`W2PO-4fDLT~ zQQYI1m>vFf{N6j)e#FihnwSIwzfzkKdBFft6)y=T5#3tX50!NJYb+g z;C!Hg+w=-1_myMdE(C0BxD?02rEDM@#vDt?CTlK9FhqDRbIhJBvh)YtS-sa#Rvvo{ z7q>rBTDd49hO1tR?_~jT^1AQo+Whl@$A8~Wt?3zmYO>6^@{8DIt28xN5Yd9stwEJn zxTQ$%0^R}WO@$#|8A14gR1#?}yQ70N_!{wnD7YSKTgB<&R(Y}F`} z$#UY-S#1asu9C1WM1ECrTmUFTrvA|%MBfO|V}VNwO6(0lm56c=4}gFOdpEFq!gzr8 z6->eWpYQWJ@ns>5$L3{*WJUas#(`Qk0yp8pb3U%=l=xfX4z%o7=f(6PO{Syw1u9t6; zm#Lf{e<6d|@6_;oGmU~x?Lih7jc$K*D9`@xE(}tN#X~#LbVA4Qm165hJ6JkhlCi#B#=1(-ZpGP&_2zC_+D<*-g zotYFqM?1TC`^tI+p8ZVOI*gw6M-M-OvH()W@mNdk&aN(USr8usP!%*5l#s9;>;zv# zFe{{7F&QhVmo1@bWa1tkhK=F#moI@R=X5<@b?N^5RgTNaoDJ%bUFsH)C1kaN_SVy9= zC-piTu1<2&U>{dult!gi*o5`y*ccH#0%#1t;Xron`W*w8adP#a|L4ca&5b`26hQ4F zM-ox?qWGeRKKSTlyKlsC;$vyFtUPf$w6`t$nmEA0Mreh$wyBjp=KI#vOg4)O#l@Lf z+>{W=FrBC2yrVk4zXwF{tCmK+q^M7!%bZ=VCk5~~{`dw&e#f3YOnh{l`H^t2isEE^ zXYP!)(#FLl0x;tV&h?V2&u}6@WSQ03!VC$KkeAP`d;$jrHcOCgx6!P%ksfXrA>0XM zticq(a-MTO`+n^7jktyluLxsKofUQaQu<1513?Fmja=`0&GM)e)I8CD&WMh z2or4E3X^3GNM};XLc+rZ0TCLu!yCFPDl0i)z9gkRj#5y4E=UhyKlksCH-5_?_C(xI z#gb+5Pk3}+I6D7uy0GEjlYiY<%OEyC-+Aw|-!K@JXlvv1oV;e;(iKZix`ozy_%1!Q z>CgNzY0FTf{WX3k-CY8&@7Z)|c64Dn;2y&C0R{*H2@XY-=`b^*1oPGe&=kt+hQBEQ z>J=rjk)x*O{J)DOkW#@r!Z`BweWVehiSYII4gFA7QreuUBUYzlGM~85033Y&@go%f z3_dcCZ)#0S{V?d{w7RF<>@e*>cBUL8!AB0U7Y^()?maW|=~FbwB?AABjg9#Z%OO~I z4bk2b2_aVT<5h{+OPGVW5t1cP@=M`?h0(<1DewkTg%kfGEZq!9)hldB3nrZka!S~5% z66`^6U{F-(+)bIi8bIciycn(@xiUJhffP{?% z*1wFxcov(XL$AeH`S&GSv}K~PVY!udA*ow%{D^F{<0P&iI?a9N_Als9t^>FSUP5Gh zyw@SK2MPs2NSZCRZ2-sC$V>MpaJX`kH9$8Bz$5q{L!n4XUq)&W;LTuo?I2?Lq%I9W zrRVP*$~xRE8oRD(iUFmrL6LGshc^me1UsLc%uH<)J|LxkzyH8(Nf(L<56RMk5uONt zz_{1phP)-nILKQ}fgWOl{>|u&6a7?{`PbSjtNlUnmYb=7X9fT-0cw3c2k&=67lD8$ z7D)7<`}~18!d~)Ka-}2(8^q~$ILR?ui=^=oA#HCTQeo%sGdHh;L_Z(NPE73^4pLH5 z7Nw`wk$VxoqQ{=Jvlks@{2LQl?kfhWIiZEe^Qiz%ecFz97xa+2-#-355EfBmS5#W6 zIQRK0;-b%sfy2bPVhdOpK33M?ql2yZCHJ}b<{tzH>NGeUn@CTb7OYQYHOepoda6pu zQAVnMsAa9GLdYFlNW4$DXfIv6)&f*r==1zgXc-|W5aBWsBU&h|IwIW!@Lz?pf#^Aa zMl&-w36%w~&uHJi$_-(0H_%NWwI$^8WdT4~9WHAbZiY7^5#jtGQHw0TKMzDaN!`HQN zq!4{6L?J}}LgWI^aJ_{CVS;RsPDxkW238u4F}x)NBLRg$qz5)}%|IHkHA(XTMhA6Y zAhHG|v1G8MXOQ3|vE<21KamI-#*a=Gy}%M20PGXS-=Bwrk-((?nTfN1 zov$hOgmTUAtG6S6VhS!Vd=lMgFO1R>3;UC=v~TA$cUVc9U*% z;O@GUmkY3{tl9j^63+$mrG%TB0HZCxtD*I6nw$P)rH6`&_9fRY7;Z3Ua&2Hx&O?CtCb0Sf2+B0_0{z9HQm+LU2%BgEVIQ~(s8G8$V> zBv1F2`)wf`5yvrc+mRQ>b{!Qnfl2plJ$td^?ftr+k2ZD&B|2v4FWM>z^!daecKX5y z$H(lPzm!x$OoJNz_IrOG)F$6@-^d!ANf1U`^mefmH01rgHTHFrN=Z$J257PauVb#Q z*c|;KJ)$bWB$Kkc;W@*w*)gtBhUeM0g1puTVo?Q3vSsCYazCcVQ@7I-8xArP^fN`g z2h~?R$)u!CI&qt;Hn#fgFTNt2BI9Yzr>q?JwerSICQ%{-Y1c&`1Bph>Qoi|Zot?oz zf5`O-yOP%S?V&8HfN3n&SURqK?2WA(z>9L}m^5YHx@C{6q{#30CLFe?-oHI(=(U#; ze=lKkAUVuHqe}_ip^XbZniz_~m7N=>d%b+7q-*IT?wR!1+d%&xKHmSlnWkN_k2!W} zo)wUymn$C0x)UCP&Q_M8@_I*2?fV8c*^hh8Bbmg=X{U;YzTn}*jc$EP#KHxgiD~%T z;&&XVJ^=qMfX`&k+^lPAxcF;m8vL_RO6Z~0MlrX5C^n!(w|L;hM<5J%2XU!=9pr)V zSSnUO6N2T6lr1`NgkQwBFrQIfym)c%v{>-gz1E?{RyEV7lT&PxMa{$FcV=3g{l3I& zxq86eC>8$>E4RTThkpJ$z0yhjyx-ECs58R4Jigmpy6dGm%zQq!9<#e!Y3HPMIN z8y_FsCz;*1p%_+-dU>9d2^U+|tsuA`EM2$?`!89|W{)~HY3%wKefU_TJVPqI$D3Kw zsJiQ;%2W@;DaIP>diSg7$-8S9X0&$@ zRNnp)$6`~^d^THmEk7@>0@f8$g>Z6lefcNL4nHT{YZXA-iPQnD=&j`BtzLjz31|=e zf!M~u?&7D@zdcd8r~#~kd;9h3D6L``D!zRA0{aWm$FW^HC|i@>u~Q~?YE4c&YsJkb zsFY8CUvg3Xw4~?Haj{%1A}H(ff2?D)b;pJYwBJd!ta^i+&Zh15>K%?0emnat>rDE$ ziFq&9tHoZuGb+ot_GXE=%osgwOxWy|x$;I7h0+jeZCtxIe*)O+Z(g={>(d%f9-c_= zP;q!p-M2s z&d2L++vLIPK8im-#_Z~G4=%VGvGhhxWQ~RV_=e(JD>UjJ2fNC|pE!8Sbe>i7@%Vc) zez8H(w_R?_JZeS_SuhHz!W$?pDn2RV)WzN zw{NGl3!s9$!;VhsoU6crk4J28H_JU=cBH2&=GdgHUx>xeRMz%^ea!Ffj?D6PyX49y zX=g%sG}FSaRz_5Pgb;4#&~sZ42nKDZ-Y%yPux)DVs>PqoxkC}_@8dX>aN$i~Pg33D zsnw6{v}FXssqGI_UwJeC9v{2e{BylmXV>2^n+juopB-B>yid`gT=;wb!%Ock`~jiR ztdp{JRBXD8hz53iFwX8OMJq`8)%*712phOZ+0d1V^Q zSO5I0WvQ^ZzFJFg^QW)h&MaHAXY8uOn%FbrSHCW`dhC4okX!2Scj27cRL&` z;twu#TP_tOt|kDdh?a$g2tb1=c%kj^pOoY*E}l4bih1$kb5~(bPVL94xF&l`y$PB% zQ1trnSWw-J#PqU}ha2Yc3Fj{VSX)B>mKB!rv+mowfFC|7k!5ZdTJDV~$v%9nP&wl9 zxy*a3SqM9=COThox+F~BSUGpaSYtNbtEwhtvu}>Yhn|0!s(T!=cu0W)G^;)QL8NA9 zXJ?7{i?7yN@|A%Yx8KA6K<}|D?Q8{zJ&V*dM5gEfNSb(d*?31-g>84lOpH@_z0_JJ8&k)@5QW230`SA?sP&r)z&02*jRB zHDdBVRI02sT0vFp+~g>8?}LQX=7SF+l<8BvD>l>{8t*Sa@ni=hIEXo1VsKU*tLQZteG9D@=RrcG@L`S#*8=J;9#W75mz9Ctyrx z7nkxY_Y4YF0p-h<^Y8lHow*G;r9s z^;_5S56K}itxA90z_h#1rtTU(FQ+9_PS%!U5vgXd<^=49oCU=vu4HT-YN9)JHo zS^yjPG!XIf6skr%Wo_y{JCwhJQ>S!6F93}8HgLv);PDHXb@EZG1`(Y8$94DywvOYQYdPCUV8d^WI`wh0F8yq;} zrjfAPk(FTklA>&q?~%1o-b<?dGvqk4I;{;yknBV+PFH8MOz=w7vw2RqM6azMbUHB(d;8omZY( z7w~d1{(iJ0BY?HNw44u{n3xcgFueGeIhC}j!9qzun@tB72XpM(zdszk77}K70apST zt%OIULg2^hv`fp0Zx3S@dit&ka6V1T&X&cW7eHNG0TI!S`+IJ->A0sX7Y`g2eOBl& zu|aNX;k;zWiLEW!2jvwz4fQBZbDt+n`@>rp;u}3ed}r(4h@QE`x*TqP1)8V0B@LELx+zokgsO#F zy}(%CvRr#9nyfXwAPEZYA#{a=*A^4$qrvA(Os!Dn-Nb^{-VqM?&>m+_*6rIYEDer| z@vkRfgG6gM^q+#l|Jt>cQ0A;v<=q8O2TUW|gg0|aNK8*plTZwFVH-T&)SvQ6ee{fv zs#+i5AY+`XV`Ejzw~f{qKj@SSZe|#@9#$i3QBf39=k%cEmkJcG*2P(8J(=~xrPNaA zgt&xkUA=*$OsrCekb!1 z$B!2gyIV4*N42Xwb#4NZ!T!^=6A*z|&u(2{R1+MWb+vuB>HcFc-+XV~S2vNiCU;nZ z*2meT|he1?N?!vy9f ztbcWNuwX~S6}lrYG6464i}NH9N<@9dBJg>~9u*FKk!P@1e0#wtJ{sFJdK@Sy>D$ z5k5uS>(=rM7cDwJ<*lKi0UumkzsP*8@O|RfuDIqj-Jx9gezNwO>Q1|R(GJdwW9nPG z#`RjZPr6|B;ZxfaLkR9y^rd3*eQ?(=2VjC$=WhkfVsl^Gy&ga~LP{b4JpkX@r^BPO zM@CMr3OYy<3pexgCu!f67G*6~L^LhY0TBO->0iO%D+E&Cx^*QPM0r~MQ0ZglYWlat z$e%Or-1UZ|;{yxS&jt0qk1e5;9bX*k9+|*mth;dh1K*dGPys@5c6ICd6;SYeV)7iTuc~n{1*}Smw0%h`t+yb!{yzrC8uu?_w%)wjQK(CD#Mh(Je8G+i@ zqQq-0!0(r%%FQR0-k33$xnxzE?Ts{5zkiA49&!IZoivK*M%2&EUeTPPSHfYB-VF-* z>+l50p+p{iSO=X~dUS@41WCO>r|_Ws1#xr|-4bLyWWbV==E{|*h1>z-{i(SRe3pU) zK)ihab8pvfSj|Wgr}e3&?qqIKw5{ZXEOa?aCogg5!#FSmL`1^S^ROO2zAC7LN{oq) zmqek&p$d@j)m#ZsP!EL|_GY)iFossCx_JiiaQZm?7mN3X*=T&rsCJTJ^{MBAw3@_S?znd*4-^K=A`O#DDhL zb8~ZFZUJ4z2c2vlkRO$^&&+=qAdc+pVj&^HblwQNCd0)stn|U-YP*=p2I7!Z-HwZF zd4hwTB%+{-32YhfU}vS~!zl>Ja0=s^QqBnppjwo`Gt9bkrv^xd42@G_9$akX3z2gN z42m9jrwg_dfh4P;tE&r)29Die9>Twnh7f{i{O)5tJ;ROpl=!}8!-YQ+SkH)u7|E{i z(BDYa+NSjAnG}zX61r@^$rDIW5xGV@Gg!SO;{sf@a_^OxWDg=7t5obprZcIGdOuz^}#QCeTBgUqV- zIMy>$?+eTNqVg4D=g~^kG?sFx%JD-^vj!s%LVz{2KV_v3O`Rs+2jueZtr0wd;{BIM zvJc1dEnQE{%won+N zPO7ilq%BI5Ef-&nJpeBFeA|J?XAZ4sJCT)>LwrE+Sz@OJ^MK(6Mv%QU+IroUp|3w@ zFx8HrJiAgh@j>tVz~oS@tnLf% ztDt5^j{SD-2>wAlGiF2t@87?_-SxS&snyH>p3W#N=9KW8@zo@0c?bX{Sv%zDgy6=+ z)O4+??n3nT2n5)UgJk^1ty?2t5{ZWbPs6cXV>QFNw(l}7DAXsCii%%DIK|a2LW@Ic z6{7GbmjH3N@w9@BrgxK!J&}f-7e!d4L!ADN0=X&`n^wIdGC{bXT%FBeSr*ps2AK1Et$Tv9viQ1 zG&@sWQ!^hc84Bj>LEE@Vh!}J!!vp{Rsz6;bSAqzxFn~xq2)fpNbZn+#RLewhLIT1_ z?hgU{0MZ!Qg>3@8qJu*n4Xbv8c!?5(+r5b01+f68QR3^Q0Nc!mnfa?{t1Lw-%$WT? z2f~Z%6s~98AAPuCr-QTQbB$chYoXhY)Ely0ThXFxr@g>F_kIlP8KTFCl@W5cbg|4J z%s8K0-qMC4&f@{WS)!|`yaJa`&#y6Uo-|41_pljQqp~q_D)G#=86J<9bN^bYWsaKe&rK zn*aKK9d}5X(VbxVb#6)&?~g*gfoyShqL&3^O4QrH|M%JPm_e*;3yS)`bJi*bDgg3O ziMssi)vFHW8afix__z?Cmh1!aBOaSA-ZboCCUkYKn*AnRtG~y7w{ot-T1M>Owc4*9 zmPR%CuDd{OxVif-HEdT=rNzU>k>k{jt!Sq2965ST_Bo2pRk%9fA1J8u5=Wds(fNOx zxJb#pY=1~N9f65))cH(Q=aRmfib{`i9q*my4-E=Q`+mCVmDY!8m(^+;7;8v)C$=`W_|rfX73NIV0&WOxV<~Wqjq#? z-iJZghGR|>_Z9a?r5osf$u)TeqHrFMk8%VOx&BXr`2TEmqCk zn`A#-5Tp_*8P=YxR(p9@yB3-R95GM9;fhmvoa^3-pH^RSH8mBZNA*$R(%M^F{ZX&Z zW5byYBjMhiMm7Y&3W-;aQe?2(#FWi{-`HBOJC?*!=jR?c^TS?>$M|C+y>J~Op~ZH0 z)4isDs@Ep5*r*dWHQDq6RkNF_$@-QGwefB7 z4jXlCH^Jn`$+G#6CbdoP)F-j@E&0pE+M`V!C*Jxj%BQ11VCoyYTI~i%wEg3c6j04e zv5iTK8nlBOX2pxBb4fpsiYSg6D9%$TJ#0yk;@f>`=v!rkhH3>3JnpS;G$ zLjOJ?5}vDc!Dc_LL}7%Bf57f;(N*WePw|ZlZr)yH>F8%)TDBFuFcAV^lE;y{w_32O z9{>1CRi9J4{t|fJvWeC0kKC;hB4xBsNCYQsV{9LD{NIl+4iQ!CYxCbyi)K!>W=drFQuuKPyXiOM?Tt&9QSYFPvG$=a1hRs zq45T=ZRPh2p`}P2^?oxIy*|<18x|~0!WxJ=NOh>b!vXnwM zzh_WVVF`Y_tjyECsO3@leO?`vPxe2)cV8E>D>P4)h~R4L?cKp0!(Rbe1hyu*Td`BM zse(ihM=Te1RP>#AW&FX-HG!o^(WABpR}I+!_#=!YZrmf> z@5CWJnVM)@MG!-LT>5a=sbbVuIB7zIv(g_MiSkQwsSPp?Pwiz(ag;H3bdDaEK3XZQf*dx#PxOH$I^~s_f7Xb-eO9Wg6F9%c`91M1D2)zp22`6IX&_JRyeH*pZ45#er;-?w_HN}}cI z&%ychxTYbSA+{~P@45{>oQ&`3w%@sLiM?YMiz)k8v2orWW{KUsPrg(3ulyQcJ#!5U zkvKQ~!~g!3rD4Hrn=FeOENFe|E2r(3nbA=an3SRNTwpCddOx<%Lf1<(9<^g!^}b{hEx(wR-dUL_NKmM_s8}d z^6IG4`($@}t9r}~n=ix>xevnXkzi zJE#RW`+S$z*Vmt5YiB3vZSdj|R6&#>q)NrW z6e*^&%FR8g5v1n0MN7wMu7i;fz^&S_feLwqNB-`gdkd>d);0(bk391`0 z@(4Rs1G_o?A;p&iHFXKgFbsZ;r>Mw4k;cB9eB-g1XQd6dwZV%f!<$JgD^n)N?mM1a zVKyN#uFtKugdHk7OLAk8etrXQisHN^9nS}GZmeLL%}VTM7mqBWEgN|s^-+4j50#;uV(zh^tzjuQ?OFp}gQd#zU7f1ZH$oN-`e}geI;~4dRxr4R1F_^NFB;pN}MoqM7diqbEk z8j)ydU4wT2nRiC!jTr!I`zTiQY5I_3iZ=$VCnJYZx?xt@?vyQFqtyt z)>Zbn$?!snY;inm+cK94N88{J{AcfBkdZ$*s-Xr&xL&$gZYoOIDxe)Z!UT19 z?ccw^&22JqV8M9HlbL@2r;TFN*jMY03K_WZB{j8nJ2Ag}q77fV@?Mhmi*BZOk5UFn zVn;MDgVB6ddEr|?3VI=)r&C$Qpm?zO1z?EoZFK>FKKu+WD){| z{@5%iJ1)@?vqJt}EVfYm+951ME;cB$IJ7!;F97#@Q}-lU9c%HO?Y2J3aCFYvzA|^G zpu5#vZ=2-AT$XZ0>t7kwStzdJqC~f2kl4mcdbxV>$`&zK=6_8tS<)n5pqy9PL;K}2 zT=(m3;=nLKMK&TQwnw-NvDqS*Wn!?M9Z?TMSUiNb+vxq#QlAG4XtVUFzCHn>QSE$w zrZQlt6SikJ4g+G^jf$cGnvei0S)3t?Yq2R&8Rigad@N(?fy<18`pE{{! zV$vC@a~%W?k-jj20iuE#XzFl)o8aRT^9Yo5BvJ!mHT`GC#Qnpi;6d0F2!f4XfzT>#7SVe+@$EwJ?ItA{<4uN4-uSptGbV4a z&YL(*d&_R2oO$ZIzSZ;>o{D8r#s@%pC^|Lc&f#t)Rpcd-QpbTCr3xS;Mf2L;1rj`f z$}!Rhx#;^O!}e4`e@kEyIHHN*aRyNaHa0d|;Sz6>|6k5i$F}&?4AhfRb=QgMC{+4lfI5h7HaVVjRGdokAXgJ(fFkoI&N~no?Pd zwRKF`LH_6-j)fTauyd^pW1W{0bwutUtwdI1>7pE0ntgoers8x5XGO@(NlGbp;9K$b z0D{-mjSvA6@KJG|jX>pV@pbWDcQ%L%C1Vyj$^4oNdPRU<^R=xj;lYd((UE`)^(l!t zN4yqR;w1oHw&1Uk$sBa|?y*~8;dsPf)`08&nE-J0DK2UwQ&YVyHd}Ob@O_8?dKe?N zv+mvns;&ZC9Yf4bO+r78qb3l4Fm*SxTWOPN%YrkF>k^V&b4Iw`4^P}~Fk?1;CFHEL zBKUn$--L#8zkb~jur&(tFT~S~mJ};4JO+SO8!zl%B6J5HlovnJ-4RqH7U*CiGx0qOrU&a7A^QwKwj|s|pqaoRr*Fw#5K`OGu^7u2nVsa2 zl?pZ#!IKCDfO1vS?|`inA4+eNH}|E{sx92XY`lY#4iRF=)u;o=Z0qK>dyD-RSRw+! zE?lNcflXlpfx&@7VD)7dTSbqGQ&d;Q_Z`dsj}~B{R_N<1pC%LLwlz+y64t1t0Z2}N z!@G`I8377+BWJux>@_wIU`=kw_tc8Ks6b9gnh@SU!EwlWuPgT$Bk*R3a%KFv7>SP( z)Tvhnivu{H)JHaMZUBT0-&JdSEh7&F*kUYIN{ASR2z7u!U;>f>OMf~0=VaLj+TTx& zZrijcTsrv_e@$~HhKSF~Jz`t?fk)TVls07D@FL4)@DYI=%Vs|}eC2a1 zK5DXeu^GKUTU@L6c2kknp#~A`++^clLe`mYHk983**S3URqcSvM@0pDIfm=<`8-?v z7W_z~x12LvFXtr1SikjbpnHqec0NWfe%4yyweIX4yA8g<8~bX7W+mr+5T0_!dVXRvE!qQ(;zuR$`sxAALdB=aG1X`9t<#(-53ji6l&0 zC#P*YCDerB3z(y)kp9eox|F;mSR~1;6f%ZFRLzS=%UJF&TJOkNl~Rv?PoKZ+YR&uj z+U~{6F|IJtH{yljLOcOs!A(Us(-&E#^teY2%~j{2wr2MhRwA`6+;ZTKbbOdvY)Hhf zgdPDrwwL!_SAD;FUgTa#emskVotki5KxO5l$C|702&ZmvSYK^$iZV6A!GI09LtkG9 z*)lLA9jQCYjSwaNKgK??V6Z;z z1Fn~f>U}rRlr`^TCTKErD}}ewToeK*f2Q|odaN|xfEU2CoRgzjGp0d?5npU6|KnZL z0j9#v#+YOTgiqbvK~uY#xOU7ZFY@H`Hp(_ypRakAhtL?+5_c28x{6Ga#qDPF~X7#s^;} zA@pdyy0(|N%CT1!&=BIdBAN9gu(nIk^u6?<-y4KK>&d^rDKXmhNV)7HG72*ABR{(C zgsQhdieKo|uS<_YB(~6a2RlZRip;)8O{rB%wj|ICl#glL*6n?35Ea;JVazADzp-_l z`6t_h&oyc-{0K6-kNI3R;i(Mc3@``oz6S}2mAA%mpli&R!z_`B!bw7!))T{=jZIBQ z#*a$>{}>XqO{gU|MrXTDIqGk+&oSRQ*G!2%-d|mG)M4*pd7F+s(`S4HB2|610`veu0GB}B*f{6{q?!{~Ktz3gc>hab)NF*J?5 z_x#X2>sGqiF?)@4zZW%U-}N(Q&2@ACZn`fu z_hUxNx_*9L{61=(@45oz&t=hyCHY5VeP+KiFzxta;l`S}V}*8gYKXxkX$-*Yyz<^^ z!P-ja$g?-G#;UP8?wJIk)SUHoS0l zC~~sPVnqmRKHuOZ!DGCzDetS=SNSf9B}|KnBhse~Yydbb(~6_q+*0Hip%x-gsAVdj zocYphT5EAZsWY##j>cRzZ2hCu+GyRe^TiggZ4Up{iu7?)MaUt2ixN1kUr9yJErDA#Y z^EQoejofFMF|YJIQE9U9JTdgtzIO5N^JQI2x#TrHpD8k2mmTaM&AN9p>IzFi@EOIC zp0+CYLQOWsPZ*je6f}b%8@(#t+HmoU^5CnHJQPx7xACIBh3_d-mrB2tp3Z@4)1us0 z6{#sC>48WN#>@n)0wowsVok!t#5jtMf+|cPV4QK>%XfcOT&Z5W=ynh7UQ!Xwn^7&k zgf3LEKJg1}+?m71iuMb&fzjdnhR=_$+hx2z{N%$oKZonW_LM#^YOd0~HV44EoZMcy zHTuA8YS7I_L+b@jOijlk%^R8RLUPNee7>Jsi}(L#%=2fz&!-_s<>1M>m0BQ%oP1IS z07{sXAjw0?<8)WZB)3q!K1K|x&CKS(NP?!AQV zYOZ83EsCGLtacaj@!L6ncTCFdU+tFL=PlF_tzHt$!J_80dtNp%tQ5^DQ&rzp9sO`W zGhw4ivaDy(%-J1Vy^Kwl`1n1e$GxppF%aVm=FbaSoj5`w^bmVEj4$Wa`qqa0U(0e| z2u5gg)u#ZVs}XCbjn-Ex=+XjMVh9rr+6&PJ5y&(ng9i5RPl{o9(Kd_n6J0#|c6}}h zZ^*RfA#&LQiG@(;q_nj7eij)>D`PUpt)3jJfhyCwe6o5E^H6i$dH0RplFRKog5t$} z_Z^Iu+PPoGCQE7bM9Q)DP3<<)j3-;ACC&Iu<`tb185=(>xqNJ*Yq!CiPSlE0I+SR%LU3h0ur*Q! zlN+Ni%4-8oF&+wqq&gXynQbF&jtx=15k~*?XL0m$h5)xPDU;;2BgG3D7?Nd3O%&ZnY-&?JYrxphfRw1JmjKi%h+ZF_h z>rw>;b=*9|`A2clqwA?a?}UF9hz1S;J^q3WuOldOaJy)K{mfGw&@#RXmNw*B0G;zo zX>s4pEO$HRuUuuBDM_T;OZfAuDC23l!)MZaf{ciqYj|AX<8h@{0Us;KT*(ch*eu)# zl(Vl{UES7sh)Dc;JNP>+Udaz6Q0 zhyDj>@UGW&?|&Q)q~0E!AmXdu$GPuYwC-fM6BCb#q46v4SZvd3hALYEzui{F0*DbN zSG{O9T%%ooQ!rn(yW7FJ(`I|OA_J>M&Y~7F+tl&r$DEv@^TorbI0(2Nqkg@86$K=UF*9k>34hZao_ZIKGNobw}oIg~TfD8Maf3 zjFd;WFW>64O9I1S=li0Cf=#$B?+UFCD*3StsKe#I6vR3^Wy#>1y>FH^)4RlCBS-~e zLx#Yc7K{|m10VH2IEF`Om(ZcGJs5XJY^*5d@_}*f`N7qIq;Ix3jkq}k-5Xs3#b)D3 ztiwc;MQOx;EhyQNxTE~!yf)zL;)dJoIYt41s!KNQ%u4L*DSYz|z0>Kh!5%yX#70s` zS>B)e|1U!z{x=k(*I7UXJNm0e{TgTs1yG>A%h^=Fc|M;}(d&v%FdDO$4hE^w{gPI!FQ`1glM?y1vhfm4mH$0L# zto&~%kd|3sAE=$O0jWwTDDV?@8dLQCUv^r1!}S|Cf*~}t2Oxnv+$k5V&yv%tH(V&jS3LX51(P8D1DVzb>qt!2 z@4EpE4@o#WW@bx>dQFESbRZ16&GPT35kr_dcEM=qgySJv$);6%ZzwH4=GZK|Vt>8i z#W*Ks3`KbN;mfRN(i0>o6NTPHiZ&M+h1r{DOCWQ=4Qq)i_ugli+A{9m<%fF&B!)ZX zT1y?i1(^j0$tsy@2sk(hUsftqybtMeRB}`L`Dx&$Y?$&vNl6A?!gO0*&eb~nxbhWS zNF%kmjIpt>~OK`u`HQ4tlf8YuyA@rl-^}m_ZLF89m&-f)HGB-Ii6TG1UWM&CLg4y z=--G!G$vX7XQX)2Ul&7HMc7*e7q9&wvLHk_9bf{c%iR;3g|d9hvrvO1>Awe8xzS3- zeBaYe5)>IN>Pv%HGhot~ukHxa;R1)mo>zY2FW4_P)c{Bi1FqK^ek1Cf_{PLE}+3PQ2M5vIDT9U`6Fb6Y2WS4Fw}#@ z;f}pRlxmZW2mon;aQF^{v6@cVIQTrOGlq z(bQ&U1fYPXW6`(Y9s1ZI8~$T06s*X%=vYt^1tt7;U`!-N6N_&So%!mW8!!Cp`(z~Y zTnyY7CKWZQQ%izdS3x<=F>_7zGguo-L z`~H#%b47XA7nP*d^n%=*DXCM{}l@lKi4tZJaY?*ZjRnZL2U2vxP+J19(O3AUpKD;W0?My8^Iy)mMPoeKTGH}7`j=Sm%@qk1xu z8e63wPKT*g$@7?|d2b(?S`I#bdz0arG+MSZ$_g^XlNfm65-A8W5CBaGQsDYr-9*(b zy>#WuOrO2p^a=gcAwC#u0B7z<{KYoM9Vezy9OZbRiMG9a=c2Rqsje7bzR7M!nH<&R z_G`4WLr)jiIxgv37WVxlGc8Jvktu=La4?O8P(lL72K!pdui994z$GL{kG$o*nm>by z(vRH+ryi-JK{>+?zhi;K0YeDzP|pn`*jGf!nM%%D=xOyS+B=ePR}x(&st;5!H-o8@ z+kAazBL{B9v@#6D1cE*|$}$e7(B3&;kNhn^4AvJED#dH^BM5AI*CR>eFfr1Txz6LbRp@Az#%!`v<^RAV=ye}BscBJRT-MqMsW>CjD*e!WC zGrOcoErsGX2L4kUsz%t@`LXtYb;q(31PrEy%U7u>SQ@jaolFDp zsd0i|wtoIO+v9r`haK8iVfvB~p>&8*AOUd9JYepUXaFj@kS-*8(Xy$vvTfKoqD zYog!);Y{muSu6#}V+gSU#;FyPN`N!{`u^SqTrMdrfi)Ac3^r<1NEa(NT6b zL>`eL4Ls})iRyZ`dQCq9=2g^KEV?OQc<1Kj=&v==Mz34%*W};4FQ~qInsu}D`@>jR zP9&wJxdCLuX&VR!*W|Z-WDE;|gGt;UihTmKUs{IQakcp2L+WM@E2SUld_#wc{F_>Y z(;bvI*u5K~c6?=|%C`=mA=&eg_^3VOCPtE6+>8O``LE_w>y~FL)OV%1rM!as`TUMD zW?ie=pJhLZ0Z=pjz|AA7dlXqHAFGF&DBUa8%v`DBqSz+jLX}y9RRx2;r~4 zW2v5u5bT}vz_o|MmqJ3xkZEab$CEzq%#YXJQ(!c&gIa)~71-Xspq6oaT;gP&q>ZcV z%fAC_VS5nGk!)%;hoPzF{JB5Eu8PM7|CWWe+J|8Tg3pXa*w#SSjS_xTF*a3HR}|OP zGin*7CD|75lQGWF!^304>CZM;qZt@L+Ih~B7c$=p#N41!_Ikh%rfd{vCfkCxIiGR` zk{xQ!euOd^NhM=T&Z}(LfK{^d)=cYVid*0vim;}2s1_rqhVH1awCSi_PCgpJ5F00no5oua3o|M!^CpD2T?$CskuMF1WT=gj)5oqnFV z2HacnVp!$|jRGgfWS7zQR7+iEEm!ClD)u|-=e*|D50F@mQ0jyJ2ULFkUx5On%W1zE&P}_FU6@ z9*_{dIo|od0cB206w*z^*~V71XxZxV*+W9@4Coz#VcRHEL0ZY%Mz;^8XRb|gdEi%w zxfyrv+{qkE&|o<1Te3{VE?$@U_uS|v1@+UaTy79P5iS=K1ksfla0jSVBYX~fi$tse zjU_eod3dSQFidZFQwjHQMR8+x>2EZh^#Z6PcZ(FqB; z$d&HbYifWGxa6--4o|uh^Zp&mpEsx1WKc|pPUOF85?HZjIC5ZCT6jkCrz|Js@NjbD z?oi4_|MlO0oh$WPD6L!H>V4E_&|c-#SEF&!XIe-2Jahk@%~}8I!t^EC(Lcv4gBK7& z4m6i7>Z*a@`!n~?YIdANQ49k2t&+-PVy)Ccu>rpB0(uKlb;VuUvj<|i?;l@B5{1Of zj5rh$x|_A@7r^t6-9n6!&=TMdTTXQK@H3HwPj@916VYHDoBr@fNk^H3N4{s3@PoFp z`|!;%_r+?S3rf{XgG=xJ3$p6@XKT5svz=$5#$@%iXjx9pEhhqum|r%F>Qe5b;F+>t zcQ^OxaIjpIN>hq+wnS~ueBjIrD<^yYKJ8!rgO> z6Z@P{JoBJ7Qa0Jn@vOCv^X*m1nUvQFo{P@^+nWm>msFS7`x`M-PL29l0=EG=XQ1pg zp!erq`^Nt+ztIcw5t?RuhR*GLav*IX8{}lE->VXQpKz9XChcXDIucvDX;pN7JojD> zZHxW?ES2a-{gVpS%x3apSq<~0dQ<9rIW}kCTA=B@)S9~K5vRi4m_50KtT1haX2b=B zmax2|^FHkb-v=BLSo)@WrCeg0Ix7?FhHT!7bA!Ljy3h4bzri++h03dSV|Nwbl50bY zy;lxuos+Q7&2Zbbzo`{k9T7($Ly=ieFCJIvc1`pHFD?ulItf1mMAr9bk5wQI%2TAK z4q}XaB{G__LN=lb!PQG-1~JshY9e!nPmfI1g*6rf<>voakJZ!2FG3x$z-agal{W;| z_9_hh8+`Mov;5xt!9;_fMPCc<*UKeM08bs#Oh{NCqI=uwwtTMSk0VWzD=7v-k< zLnINBY~9TUIB*mf{YW$2SX>G`7b5&g@+)*-a!6U|ZeGrk6Z(NZ^1N1?0Ij zWH!OQ&~7Y3t%EtxM-@cc)g3O_S(qdg&53Y6oBR~G#lqsN&dKB}%zE`B&_sc zb+~3Rh*rIo)OhzwRyT}6_d?;r>+l|62u0D`^!_r_MT`(jf8XL|;aVsn)c{75SsjP@ z7#{X@QOuPqvkt{IbWL^fdm}Az2Qsi==xI@+>cN6pz!0x>eRv;QPJQkxTvt=LmZK=n zc6yNo{2d_s>mOY1xILIkUngO#S2_@WYY3?NhUKeFaXbM zh2hkAWcF5tHw_pIS~&;<2KFSv;{^Opl>a_rD2@bfaJ-3ukx>x)H;|mCK9?GdsO*6P z7}OuYJG;+vPNx%kf+!S(0FUu;X4=RH(vz)qXBja$;q${urumak^OUs`?-iBx&pD17 za+=BR+Blqg^s!n_@AMZ>t9Yjm%4VYEV+r?wlgamL&v8_k6UDoP!DY=XggQ%6RS=$5 zpf5JsCuaTVulqUn(PdQlMH%%hW#QPUoYc|C`)rs$ct@rqVE(^cfKJ%`(-q#0K=B5a zy@2qVGPyvuJ2<*PJVWNeK#o(NDn_Xj7@Gjeo(CH#8keX$a^)2jU|Gr^_+<|)tP!${ zqbhi8zXwR)FX_!OZ~=Y%SZjTnES4K_zm0%J@j7UAc6Ru>H0oM1X zN+12gk<)!7*CXBUj5)ot2=4zPQ9u|ob_n!32kn9QQw$uNbxcQ{uMwmp-rkvkvm&nP zVSf43Pb$Xl$^Fh~#=)}Z= zc&!7Gni3w7`?zKO`~Pkmlg}IUCN1~VN+>`ZrE;GI&Zgg1ddvq<+r4@SclC?1Lxx?; zGu7~FF2~;?ZhZRLdiMEj_k@aAdHVQv6Lnfg7vt2bIL^Gp{#x>=jx9w+Tw`rE@yU8Z ze8UT_w-brdU3%p!wSuRTd?q>4I@-z|q_B8?V2$RS(2ki8V}}e&CG;m60PCXY_G9fc z-rxR*LIORJa|1B^-v%ijRFnMXU)Wh$qmlVCHMM^YM+is9N+vNn8ke*P=_+Ci3pZ~P zzpp_Q(*jJ-o|SpnGshaZX4~7oAc(06Eyt3&*D9BTf=T6((}?O5ZgOXCVXTe@9c2j0 zA?+j#n{`fdtdBVKS#mEY8YqlzM%TzCTNbP$@4kH3=559!hiq-?{d%gL*aK+XZujyE zboS(#R;DLdCI@!x4ViQ>;_f>tDA#9S9$+;$E_2g%{N?z9R3u8d^RN`Z!+xD zZ!mgTQ_3Fr?wW)--+8KDYIs#rWH|?E?d;O`0wIz^C~H-c$$_2(7Gl%s@Zt zhQuCWWdh&_1;m8~URuOk9z0hkW;Y;_`?m8-n)lEDWOB5JyrL$tuA%*mlHke$4+O+b zX<>X2=_Vj%KA_S2`tYZRDu_OS_^axRR zL4pCX@<7O{Q11YurYD_Z$7-zfT3}TYXnjlNeo=@iG2y=mnxP{7MG;{r&k$ zjKGVR)|P&Ea&2bLDW#p(=z2dRh#j8h*=L}gapMxJGgHEkw5+V z_0D>@XQJ=}Z_qL1XQkU_)1|eLL<-mm- z`h)?$4au98v+oRbT?mPHiQ>2JTXq2?7RaFWyZV6n?U3#gji1!*? zE>fWb{P6Kqt2@4w&_Lf-|-kydK zzyl(CS~qS;@(50$7~;sFj6o(VAbK(+0N)V~d>CCv{AQt#a1sDl$PBb>ZSPNdJgL83 zU}JN^D3dF5Uzc2}c<6LuO480vMEu(6%n=m}TGo zVNOG ztws?_y4x@8w^dYV2Lr=NBw|H+irl_+Qu(HGpT)TSON1a5e7v6zA6Ha1xhV3sUGb_^ zSy_kqDf6w;L}EbYbLB^qm2Fj3+QC)#>Nv7z7WoP2UYM0yCmE^|_BPYp~2__O|+f38C zhXTfrX{qDeqY_Iio(hDO#*>m7v);LDIDCxeN6R(gj33i{88k6x0(}Qh>w11u3)l5L zJr(z5AUJ&Swtcf=v-ygGtB5GYP6f@;FYSeZ zkiq8f>1TCy%-kuIzKzF?%Q9aqmYG!$N8N(M3+d_Uhkp1Qin4(qU$gpUn8>lq2{$e? z8Cuzc|1CDAiEcwFDZNl!YxrKe;~yC4^^7GE^3T(}p{p{@TW^ouw14*dcL*lst)lAX z3&6@{5Y9;0S5;V9UPj&fLpxR7+pD)a{RSaoA|pF?!Qa_+iiZ~(>FftGq-AprV7F6s zV7>kP<_?1swFF)^HEsV?Nzp!;sVB5C_z{oQC^puV;J^_LH~*;!vCz!>o z9yNzld#Yc4tyeQ%L?n`csU{S6aM8I2l<-tub)SNv2LR1r)em!25s#nAp^A9F(`0C;7=h<_in1gvY;Y*8ItSztQE2Sx4`R!W~#~eo+oigP~&Rx0E zs8M7_cR7PWpRgOv8aqyRKI>D+8L|+vGJ|Tyf9GdLU1c4*vkbHr&F|RlqEOdNQ@+}H znc}b9(s=}+Q_+I_)Pq>|Pd9Uq@8^%a=NtUF)or~@SWp;VTl_II6A4X9q=^L+4tjAl zUmL6>ZES3UT7;h$Jh74TsuNxZxfjrqNTK2lis1CS<*+uT=)OPjRCwV}Fn9jc17QZC z*F5~;;o(RJ9?lo{u+)8^_=1FoCeaY-;=erl_eTbFh>@-p?%&1Z@8=E#-j3Lr|B_yY zehx$d|D6ZZu(~`xKkcfnLt-67&~`lbgs?CrJHwVscAk!9}R~}?nmOQ7d2{%=~&j1zfogSy=sp6VZ zHzR9nIe|ezwoGAipNFZ+l4?<<>&742yqHIsU%wiMj$2vUgpM1GjOg9R{PU zDV@nKK}U?Jpn!6X_DSwNr9UrRv-YrDyLVo`1Aeq)j=8ZV3{Q@r+cB1D=iSy(h6 z6^s6-$Ja&89 ztR^vwrdO=#QJX)vA~PL1cdP6gCp)rj`yU5BpouW9h-)K^_xk$fQ`m!rO`zsV3fz(M zPU{P4iB190$Nu}ZR$dW=qVZv4Kg-jwVrK*2XPXlo9^TO_-Ixif;(g45dERU_AO}a9 za0ZQ4)tJps9kJ+ie)Wt2M`kDa!HS+3%INfax7)Djd6x9|Peb8T?CcBuEKqPPr7Uc< zZa4P|IW{eh;$z0}fBWoGw2K-aFm$x`eEld@^EmY0dr-M(?P91&vEuRXRmKW1J9+Yk z&oq&WwM1Gtyk)ja2~qVg55YRh%&+s_3=ZfFXqb!^Ye`=kE&ZrD{*b%_3mvH9O}7(o z@>iRytAb4{Mh(TR3!j)(#Of8h)rC%dk`E794fwv^00B%aix&J+!QR8)PDtRL=z>3d zUPr6aPZ^?cgB3kka(j7g+z*BPxpuEkgvo{T-$wqoF(r56iL0wmrle{6!a59fg5 zc;_CsB>FKMFQqqg5`O@`Uu$5y+04|m4Ue_xYW3G<9g)~EFVi9Cq_O2Fu<{c8Ii&C= z-)bKW_-KkgP&e8za5ffSG((hqNpYYq@u;KL@4#8R_4%a~ z7LThx(#qfIwk=bM0HHVIqXi}Frmh=vwP_jCpMTb+@oDF4;tJ0_5Gjl`==?TXi;oHM zwttyf8t^I8B7(b0f$2y2otdglrkBPBhDG{rTQ|%s>1sHqLMcYCCty_8_znX8#1(YQ z-izQVJ0D;3REk81RVF9^&vZ_;QCc`@)XL+Mgwxh?%ttS^B#?yuyXF<%0irY3JRAF~ zjvj9cbQ5d7)&1iSQhUm|==YH;CFp37%|`6G)ZVHfhr{S6Z!N_=T^cZ!v9jU@RoN8C z!CAWdYTR3Am8{9pQ|t1;Vu=ine-O(gNrJP;+1C$c|YCnT}gbVd$9S>Xh=yB z-}#hrX6o64U#cQm__YJ--Teh#gT8Vj$DUkrIfJH)WVhejUFWb=FX8-F5tDD1HqgYV zT}64)+^hR<*__PD`eTcA+&_6yLoNv)}3;H4bSI;+Y3SHIh+<^vYz}U4jBtPmu=^L%qA_8x00U zA6z@(WJ7%T#{BfFDm%9CX~{2Dl4;Dm=Cx3eDp+p%Cw+!9)YvznyD()bL4?Y`_@vkK8;!+RY9*A@F{`xuJFUxgGnGtJ zPc@FfwtTBk`VAhY23m)Dhas8RK}0{X!S605=ckE$(%pZgHZ&U3hO<>r9l}h~4Fm2l{p~ zN%ouu2ZQ@~l*-pW#*DJ+3g-L_+B+5Xp3^f@>~mG|OyqryFUa4On$FE-3b=Z1S^2C9 zI0AL7y@u}YoRrT`H_}?ASI4`P+~UUrT)fl`9=)vIQzlasVSf}cRNiSTtf_VLc(&v% zdPs!9w4*9D$L3?i(PK8v3!hFf{itf~BSzlAPPT+SFeR{dHE7j53;A=^@nLY`4lHd> z5Il*6I(jDf^jA`K)w?pYW>TdpBi6_W~XE zn{KXI-P-OELFlxg-gd{Ns{QAPe|2j zc78(+ghv=NymDL)H4@L1*XIPgzA(3K`U%%4fk-8~XH5@+t6$`1Mu( zE7a=5haG94w`LdyE965w3?wvyi}pg~TF)n*XSSU=b#m|rq8)>{iNkm$(AMt%3YM(t zu1+>~3?Hc@Sr2-C8FdZoET6l1Ui*|(w)LQW7kbm!m5DO+#kvA$n?lF#p6Uh##4}wJ zre?}l%2zu&+cte>{=GkwVW0Y*v!@0Bi!$gZ zT}QoLWRSCk{eZWrm%PJaEL(xJV7)49LaqOf7LRxf^o()oVH!MMzLjOHS@YOw^%; zk06meV;rlOR{3aAj|RN&rdFCagKgTv(fZVV>xZ@O=6+c1q7QiJOSJc&zw_{t*oBUv z3%@DndU(~45wz1O0pjR}Jkd=Qp-`;4?ZtRstC`N%XVnEe7Hjml=|pNm<@GoRE33RS z`JDu1T7vI~6f5>AHJ)iAHuK`GXyS{c8Z4WJA4d+s`{Nb`K{)daCDU^Sbc^ZSEn8(a zf?bW7V=$VFK=>76==>M;v&|5N_$-1NDstxvN6F&o@8zik;`2@sOvuWm1=v=IABi`Y zT$VYu{=1uDr!}Tr5wmrkGB`u@0baDn9WH;wO5wR6=ko}nWR$r=R&y-TD~_t8FX7LN zH$`~Sd<>xtYLz+|DYa`gw6^<2j;m_fW+hlHbfEBemD5`$B8X51AV?X9gvC$^cGugi zuJ(X)QD9`~E>Ng~(S&ng|!~AalHg(Xg{x1@G zd``~JpO5!(pq&l0?VJcp$ z!1Pv2w8Xr?%D>X?vC6ZIAU@y2x$%mFm+*(F$?5zXB)A+c5sfk-U_i{ZmrdRO**>%| z4N7c??>35rU^P;R9dVMKfkq^7xg2%|LDo7gNm;~9gX^Q zVv#DCQ?avd9g_Psc5L+*1MbfmIi5nUrUL^~W~Q3~IajhcDakQz%zSuJ6yl8qc|JnO zg8Kgs$WcNk@ez=JnuA2n-tFGHc%L+0x!lg@>eZ8A1Cf8!&mIpW-||QMpbZggnRr6; zzQGL&9EsobH0XNF0g@8arm@cNKt~{r2z4fsIh1DLdgrbD?Q1z#9u>ZKztC>jI{EB9 z%+f>X%pIL(#+O>A?Qeu!fQ7F!oE{#&(7MjUfXgY+6`b->dENDm@9y+Z z$l)QyU2pzpilId@svVpF`K0s$AKM6`t34(UXs)1Ufd`=eC8)~eg?rL5-IPbaFTXPF ztN7w;N8xTntt5VlKFa)chhcR2ln>TK*heSVCP|=~EvQs{zcmwu^9m`BB%;2peka=x zb9m`HTRJKuolBl{5(f_pr~L;1Xnf|i=dK+O8mA=0e(rqGYpZA?%6s*b3{d5e_ku#+ zieb{?YjzCx-C(Zhmd0-8O{nl-cN=Cw0LzIh+$T4L2bnd zK4c{|lG+1J;G%>#8R_XC9&yyiQN1|-zDhNbmX6NySt@i7I@KG5&<(D@lS2T07=Ne| zp%rGmS=(x8^wA$za{b#a&#LyJczj&@&=1wyXVSW;Fm4~NTvm;3ZdQRQ)6!qpNYM&? zXj~)Nxsw>X4#VfZ5fNwP{9Q0SCp_pdR!Sw49yQZ{c~e@isu z3ztKwGdZp(Z?@?Q*>-{6BMKA+8dI#1G?V)rZ6OFhah-f!p=IH2oCLt6}4U1FJ~J_~@yyzv6R&I`&Z6$j&Em*o=3WKiFHv<2r6j~+Sq7?-lGwbIf&={gaF8v) z7^u5n^Uo+E+Mt<0%oAn2t%0YMB#o5^1!EX~Kn4!Lcd`FV;LiOCb+#pPjS)Py zJ_2pC%w7Y5kBkys`#aduvM;Sdt6lP&7{~NqL+%u9HVzJ2IS$Pzl0sA}ChHkUC91i65`{!b!O4KWL~1d(uYug_NUw zHSa{)7yH#fZuE_zW5;Q6SHza^uF%6rWHS*xBj6PzaY&v6rHp&l0$ON(D9J&n zIO45!u3k#qMPb$&houpwb+z~V-hVm_%TTxkyDy{!j&k|UW49Pbz6%*HpIrhouR2>t=2+0>jN_SI;hZE!zQCKi_>TFK9*I4pYl$N^wYGd~MLp{ZC$%}#)+Hg;T{J#@!1{C2otT$H?`2?bwhc+M9?#)wf+F#5Z&mag+A{J>nYVS$SoY`rFBhQN zT)a*`?+w+|DRlmw|HU9E=8)Pe(2r2{%{Gkce!fKu`ETocY=X&WPp=3)63+b}1P z=imyX=!g?|rA;FXI7eALb)o?t|5wM0b?Ptf9vszi5&yg@g zSl29uf4kk3!}sV`qq;pQy5+~-rC5+Fi0`5?``;6}Bo5sjLp)_& zooJCz{8Hc=IgU8qK#LB|MbsQ34$#B_zt#$9*t@l05OzlK3^idnMYvM^LGN8I zH?xPG?><)uSwC&TFNt@&-1mZ51?OKgJOf1%!Zs~|bTZiF!t$kcK3ad$6Wn}!)3bvx z&UNhpQ=S1*UYCHc5m;`mv|3y(vQ_%Frm_3e2MMN^dqhe9gi{c#Kr5w z@;##?kR(WQ@PCoS6CvNVhyVSsDq=;Bi7@IyGC~`{C z05flhX>v5cKqF{*Wd+INkdD9|z2YDsyUKvzO@%_#$xy;gN=(SR$XufJUE1^u5iXt= z_w#yOzp2=Tb{NL}M6=^XD-O^&uDX{L=o^KvE`_1GWV$zhqmCG2iI0Po@dN1F&(qYk z{{*U_g@PM635C8)=&BFgo0^U!Tm;fP+4Ik7anj)W4y{?Rt*H3gJD-T5q>I~slDA0B zGGe4xQBN7OAlsv4_W-*YQ%!}}4F%w44zFzHyD_*H6+}eJx5@y2EUu2(=0!1@@ z*|5yy`GFrO+^lSb9n8dmELkfI%V~tkOe=2HD=Fmav${bWDuDO)gS@ySp~b&Kuxe;y zNz+ue1l6GQYN^OJZ1eWt5ZUAx|QjS*fGTLM+nX==hhB^jze!`t!Q zt`4p(W@-D5EJPu4^R-hMp$+wvD^ia&&ZBgHwhq;>Jl(n)Lb8RCL|3_Q=V`u^e?~=k z%Wm$_5o;pPRA?^Kp+TjgXVkKqbl~x~K=Y>_9d4yQL?TUBOSr8E9rWzli(S?mdo3Kyqyp>4GA_Gx zt(u8m6_Pc`bCT0%zG8J@7w%u2JK*4SF?CnWiW~eTD2>f?ork!Ol+g;L2LdfIm`ZpW z*-Fc`LS;4eQo|;=>+{kO?s>na@jkVl>cV}Hb22lKV0DMECWL1YJ^1Mf8 z6{_2R^FD_!Ep0eB-55`8UXVYK@L|P6eFr4iVK50{uosAxcBWQX4xL32xG%O6=uVxs zHq_j0@(v0&SYJ;=JLF22vO>&KzH4}?0V-33bOPrLFgQjQ9xRs0f6BIracd9x$cqVS zuBB9;6s0;9m(D?0PS*CgEU9VSkXWnsIF1-xuI+JAO4u`-DuVh(!^IllxFO%qduvk@ z)jG%(dmyWpgpni05>rA>n%zI?C7&ISk>F8aV!R?K`Pg*y>RzMMh&&65$b;QI8s6Tz zI7}bcI;7pgEIueCK(}i)Z{yhTAXs?ht64io?4WO~tdzB-@}Sw$~}K8$uT9$ zeV`k0_qT2dP(Ts?a*PReHIz60P)iA$nrmqqOovJ3t zs4sudy1LV4@(B5RiO+iCC57#gAL%a4S=5L(j8DpXq+UEJRl6EV+~^YIua3E8dmTy& zt0d0UPAg|6<=|iKue?OxjxRo}8Fwo8nq4fTxFcG*5ek3e(UmP70f_>V5RBE-P&{Xv zo#$_}7tNTTnLVlnrcpfRvhn+ycTmz2Tpt+2kN@JKVmJ=XPO@513jtL#p(qGvx*|2>PF;I?OR^9(09=?QPIZMRCX zqV3@S}V6cmA|H z4X}(PJ%=1e8&n+MK7c*!t*H>!%RlHx87#iZA_R6zLY%+IMQ<>otLi*5(=7&_C7gYw z`wL^C?qgu|Lp`F}si;%WSsmrYG;O=_GLOLF1fcMfC}OOeI%p)OZb+PZd*>kIs9k3XLIHLkRFI+h`? zb86N1uV!f`3NrPU5Anr0JBGUPCt;PzxgD!LQx?BuI=TBgv+d@o3DAzxC^HcN5yQB0 z|AQ3gjD^D%(mK4W{eWEq|AII z!O|+4qE2|lxtrzu@{2PT1Bzb1@^@}99OBF?Eh2$8<w{(y!2W1Q?bwpdb42uw0-CgZV6vH;M(3>(Wr%47UY=OtHq09tV)ORp?b{B zc>#d|?O&MrP3$VzrYf-`Pq1W~u|EpBhq;q2HoHv)&;jZ3bs@)Z4-WNe`+k;$M?bE6 zrV_hbHsm?t>}!8Etjhsu{3O8EWU6rw_fo2Sph1Ou6F=wzrvuiod{M=$Xez?|=;bOF z6VhUpkiz-V(qSpjhxy@W_m?}%0Z`MQZKh&Jo37AXc&|R~z`JUjsw&zGL{EF$GrD1Z z_l&N$mg*0(@?7J%lG11n)&Pnw_f9Bg65r4))D9);FA9@n{VIQ`aLK+(9%+k!md~Q@uzN&;I)B^AN_ys8)<#5~3 z<>5ql3YBXA;I7J)@Ouif=)F6-wW3iBgpv{YTDx)0DcbU6d)5e^Q|Fy9y(quml!iGy zwh!)Hjv*Gx%5YqWF>EtTe?|vaI$Hz~f~JYH?@@-a7J-PyzOY9H3=XN&zSG>X4kcWI zsTd$4!en3F8M|{0y$;wB@^5qV=is@&kmf;GjV{-zsXbsPNF`Deqlo5Wrj=MWloor} zWJ_Lzq;4!cd;3Gu(!TlE4-7S8h-#ONB@(G4>Eh5&V6qm`5ZaE!ZQ0WPnz+2WkQNB? zBt7KKp~8{WxGr?`iw!Pls%hRgvw@ls8E1i+52X3hdo1A7Jskqkb~S?dMBmNQp|s}G zc?ul8Fzc8Q8;e6}jKij^5L(h}#6e${i$K}y?7jHuZma_ah#7451ugBgxTC4FOmu|3 z;$^Pi3q9^y7%|qQ%_-!(v3hKB^?Rd}0D5g*s+%ek>mRPoFOI%ldYLI8cT(w+olv`B zu0;&{)s9lUt7Z$gxFz0|k(s3;cT)07BAO<}OFy&z@l;c_JtR*jP|z&8gZ(4e)3apjZ?Q})+^ z+5`r%WxobrluU7>DZwh56_JJqd9pfC{54ZAc#-J-!@BDE_l}K~6>$|F$g+KTT8yH+ z?!G(x!uv!2MaH{fd9|9?k+r8|&&XwxGGzmDTVSG7uu9ppw!-yWTz_chHC|ffLv;1E zr6&Eo}8YE_oX;NMP=%h566Z&mcyNY(BP&a~Rp5~#dD(*-+tHoelZbtQV zS}_2m%N{IxrYW5Xq^f9B2VH*w=B52@6F8-*fj*&%`>fZkd}WG{JDRy-K&U90>9ik9 zQmKRM%@h{MnG@)qlT5i_^ghb%0&sf#rJa_F;@M;=>*3jkg4)vo+3{=3MU5)L>C}z5 z+h5D%sKX7UTQwDHW>iZbT0$Jjx|R`tTc-f94IWNSiuZXfEQRA(d&bJ+#~7~B)?CwD z@sWQO6XbCzh*4!qJ!Z!uyO1~<(^d9ND_LQ#LneF-4V^+nJYsYUP|8*_IibmMvW*m) zXx8(=6;RtKN?xkk^U%8d_nAF*vCc$UHT!%)nach_Uqap_R`9z+a3G5Ts} zaZ<0->`q^q+ShyrripDa&ZJE<3nq5?zS1jm>Sgo8{WEs7&GHeUl>GR0u8_uaJ+q^X ztgpO}como49~zm)$d33XV7v%aCx>F;wcq5ZVYXZF(3QDR0XO@&a339!+wvEiN}6XG zLUiOg(Y~3VRssTV6nf1B% zV-WA>L8;R=;bVKaxe))aAoN8(YV~DaLZ_^3rRC{I>caketQ^0hl#8{{r=huz(En_7 z4BCXV=}*5NU>Q@(^GKAed0}Z(RMC`Ip0<#~Rs7CWk)`F|S$U>t(NMzE+kSrw-kS=$ zDo*!OqO}WRgn)p_B+WR(KrN|?dq!QQ*FUbnW@P)4?416fAcw6q8+iW4d~i^z{IHj!A5 zZj?3`UOsQf!~gb_W2r-F7yl`>k@vQ#0dpt6NfoVdHJug83F

TMAyXjFF-+g{<0 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

CC=t}%1a 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 z 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 literal 0 HcmV?d00001 diff --git a/doc/manual/manual/tubes/tube_slices.png b/doc/manual/manual/tubes/tube_slices.png new file mode 100644 index 0000000000000000000000000000000000000000..81acf65dca3a4ca58a5955b63baeb1fc7d2a1e01 GIT binary patch literal 184080 zcmeFYWmJ~!);3B=H=;IUN)fOhptF zbPa4w_@wg3G!6<1RezA4k*|)GKfR~7hrN@l9ldX$ryadrfRjB6O2AY}j#DbNhPimZxM)i9u`mv+AJ-qIGJK8#bwQ2d6^=e(8f$3^V zz}aG6F!gK4v)>M{Yr1|O?4S0IKi<*|J8JFwSbD&=%hZ1Sx376{I`nYo_ZHT@5TYo< zKXl~I>n9J6*13buLXtO{@!k(M7hhT3KeH$c<4*talYBlnVkeNpGN|(W2>W+PN0{U} z4*I!BXz#|P-TB7%j1{*93Dys3GP@z_t8L-M=LxD&Gr|i|~!2WT|bi_lNOS1EP=O@<}k4`1YExNGs{6C>r z!cGI#3PTO{O!xM`x3|q4^ozakiP3tzC3_mseUNaV?p|mr^l>D?u#xg{*_OvokD?0l zl9#8uX`SqQ#LANdBENXv68sFcw5siEPYDiC4x*^-J~@9OZ6?rw*9PEyhoq84=6eZcqCpus$KXQPLaiPT$!4a zhuQn-Ygv9am7oBJ@vVC6@oYb;8yRL*={gUjyvFqED-Beu8^T% zp{TEyOwI;v*?10iWnksgzP5Tu;gB7eontrg)jr=wTY{b2)NXv-z|!Vp?ybYxz87s9 z9UpOGbwrQ8u$JcCJ*If9)7Co^vXN=((RP}YZ+!B6-y`f?dg85+%Z{CjN0ns#2Thk# zuXuW4-ld1p@{iFeYE)1$XfpV}%Y4?(()}Eg>>DG0)#=k$!cW&I`kCe0<`p;1{@Utg zorEn7jQ>@g{c$enqfvemn{^UAdzRkFNom4ulh38675eNXU@$K6yh}gqeDlMK-=v`G z`Y4}3rXm($;cYzs{M5UZ&FEeX)w!7&R6)rlv1kSxGaA%BztU!6@;BAm2J?CcS&ux8 zExCF0CuS%rzDa0qXVTt|rY{-L%~xWJ`}s-(9^L zINgm3yVOf6X1I?mf`5jLi1NRekESB3SHAgP{-9d9YwDXz1Vw1xP=@i4^U1IWW<6@M ztS5b}Y8Mre6+ijNxIahC+&5ywxYb{H-v-9rX}TFbXz$#L?0L2jJxN-ac*{FV)qOcW z(4LK(rU*q=Vn^pSziD}_^RIiKJzX2g9IKYzxmU)RzFM%S=G$bgv^9?Qm4vXU|Sx>pI<~!btIsNYZ$Evk45f zFVXS8v%}?{_|2>wB>iTyiFlxog+1$~BQg{;o^Q(@D?rHv1?|nnFGfei-zt9W$i1z)JN^I*@ zG54j~e{Xlt{vKW1geci#7;Rl*kM8}1l#t1z8*=EZLoy%ZGZ%g}x$iq&Q#V=8a!amr z_|DQu;fPNhkUM86d$r`#Da!9hD_3XkMrur&-&Ux-01TSs~@#DPFF!|m^V?Q zxQTn`OMy|Ak|Jfo;AE#)}dM}!Ns@18~t`^O=a_?4#gaNZ{{VkJC6!jaHYj<*n)H|chrJL%K z(Qmc>RrQJ(y-SgE3ngWEboraa-Bg^@h^3%@rCIULXIWApJp%c(6iULf6=nP zt<%G%r}vpuk24hv%~j|Y5;Vok_94Zm5W0#X|L%REfm1;V1q_wjq~ zn&epR?nb6IY*ad+sD2+8%_%MM{js{Kz@qTgyqjU#LTdAV_Cndx8_9hcG2aaNTCR4D z*+YJ-1?lA$dokwyCCn#*J-Z?u6xk7$I;h>GBk|z^dv=<0M|;Pb z`DIJ4b~r2c$9<8^OSdH>O;b>{22rDf^#77eN0*Yb$Wd__xT|*kI2&UL{7SaiQmXY} z39F${Wkqo9yXLOcy8O$iM)da&a5p!&^gU>6g?5#7-$(uQc|tVCv6oJtpi$q~F_bMu zp4uI|D>>(KyClZQYUP2?*HMP&jvAV}R-{ywfzTcIhna14xVczB=Ya$ku zFpXO*m3!IpkQt}GQ0|LgY6x0$eJ>sRfexWKhH1r%wZL#a635qQgyF>77*5jYS~LUN z_y!-J+Pz2np+q?s!`JOB)psdg+inldnPE4$=O8XwT5p`x9WPjhFm}3tH?*}XSzhDB zCX@^fCGJ#}XLrV#E*hP9(Py^%2!9Cw)~}bfSUJmlb@wAtjC0aW+uq!MTTgu~Jg#v? zjyugj>EnHCRt_WFp-9wqjiSr9uM?(hNomdv<)7iHokr@c6x{w8Ojhym`l#IFmm?w7 z6a7Blow@o6R|&R>T2P2SY&%|^x?dp@L8^c^N#@*{;Nr~JLT?&b;zswEQAVS=picYl z8!~;&KdAaUg4gjd=TW28av!`mjPbQty`sWZak#oG7xga7jt~p`g{nSH!`)Exnf(4& z>eyktJ#Se3CGWkRQZ!`k&b8Ru#xiOWpQ&$Wic}o(k0m!lH}|?cfz7LB!BjT*fT77$ zCdD;Q)WJZK>R0noh7>a3X%Yx>ltG$Lh+}JO1ywu^tRehOn^jaHDbKuj}!YT77T@Nqz;Su`DLuqH$p1j>+?>D8B=jd2Cw+bgWqh+xuOZvDU<}MKsZ|mI? zDP?R`Suj~)c8?b=d3H(C(d*8uDL?(w0t>nVS{Gf56kW$81!MUzo!lNnYJxumtq;v| zWsFQZN!ZBz@dWedQS81`p=s8MDsO(OE6ndoeu*LN%c`m<^4sfe?@9L+o`?u_0hOpE zx0Y=bGo4ZelJdZC_1|O_{5$2sm=zJb-wW^z?l4t~l1*GuANunt|<^B*oR4sIB z$!5Z?=}=IjC=g!sJ2cg$*&%IzGB21y)J#ia_$JkrN&E)kbb&6VaWi zHabN}WOjPyNx6oT6)zSg_C}rZTFC3^L-OV~!j0iaII--%L)OCLuNXw<#L&k_DOP`@ z%MZMw^k{Bz0wZYe@|!q}l`E&5L+{>hvVAwrR`tA``?M~a(r|%Oj6sznQRg-h3HMlE zy>pgw<#oqWbdpQ71`Gz(0kJ714NjKAmpE7n?tXYebnKSbIM{8Ye%SSl!~J#umYHtLow6wPmoC58e^xtm)z)?+U*2TV{>W zoRV^vfXm)kj2czW=G!;h1hJSHUq$nGnxS4kB3&pYL#JOISwh*~NA9%czRzq_rd49E zYS?7mMfbK+_x$^|?^?)B=4*v_Z_(1whEj#?+Zzq^ZJ{ktmN`^z2Kx1Lee zdwk}E$4qPsEA8P-Pgt*cp+4JKJpE(GA&h#xvS%ed8l_wP?jlQkS|#^3q5I7RbuE>b zODX&@A6Ym(z2CH$b-&E``o4NqJ??r=vcTWXS6$uSH`kTZwZ?lcPtk5oEC&bVpJC<@ z+lqwW>@59293RZYpUF&2FnvF0&Wjy*q_MR-{!Bb# z@f=$ozO%XSc#R~x&x@rz(xTHiieFT@l_xJ|gpG7nk0!1*;3I}x3#tj~V_en##9jhY z%T#QZCOLDdSiR;6u19vq*r)e3lWT4|>hxPXA1-p%C9-Tey)+0mdh;`!<&k@jv`z0@o#eOo-6f~-zdr0SmwhQxcJ&KN$ElJ(HEBr6 zpY-Dxdfv}HK}Y@AOnxhsyVxY*AIF&{a_pl&@wYrM9Wrxiq!47@Ol>&~Oe9Kksz|5| zHw$1{#O|jFprhq%_#C4yJFXT-+>jge=6ZxGc@efAQk{9c+N-?@ZZjZT0v zEf=G6*CR4^M@9q1YgO#e`?7`H0F|rFV}Ek9=SLa~XbMpD(8X1}sLA!lh*`2cw&@8> zoH0~xO40JCCps!ASX(b2rHBvt1*2b~&oN7XX{@73s2!OlO)w^NV_%9Ppf195hmyMQ zmT5`2z`bqtU1*FP#x?>M(X{$*o{M z6}4r5@gTR?MWb%Z9h?{_6>bosM-hnrzJ@@gAnD5k{R-waA3yuB#t zQm7kA%YU(AjywN|l&yHti@7a$F6b-uI0=pa$BfFD28$+n?K2{tR0ZaCQiaY#{P6;5 zw&VzLx<@TiC^T2%Q;NRhdqsY6|J}1qe<&#Bc!|tOLDA78t>TAe)~(GlI)Z1O?i&>B z3EH%zdXpUcwkg*JREHW+pDABrAEU+RXpzBC9UkT%;ivj$ahjB^MW7rk|1CSj#a9ot zGAe$}+Ahvy)Ml($K|SM}TAF&Q1F27V>qqm*xST~Fj77S+jWKL{ylI#_!HyhB||Cr1zpXlk8 zCH)NEgy23>mq@wZRNYr}oejL4p;huG0c&!M#FKFIiyTjZ%Ys}zj^zG)HeoWwWEd|AF;_ovN)bgQF(?sG72 zV4F|uIA=O;s_C#$Vw_niv3tu4`EO`3yyG^HZ`M?7!c!4D@F|R$o~8*dv#PdF`I+lr z74KQCm?eK~hBxl1Z#n;oVL|ct^lHx=&+*fyIy1?k8Up4g>k@qh44k1jk7FWdS?QbY z$6s#iR9g|Tzm4Ui&7KN&tNF2s;@Ch_Zrs}Rdx|z`CzeW4lr2)|4u+Y0G-@(2F)I7W z??a*xFNzyaqAoQw7I^JGTM@Uw_AY+Td;c1Da#eUS>#Ew#lx8e1RbEsZ6`V^q(lDiM zCP|EyDhdL5RUTXZR?1MaNcX*0(iMZ#xICn_nej`i^Ucvz;JE!dJ@};?ZLe#V&jPQd{`o=^YBL zp{sAF#45-PMm3gJ2<09G#Dr5^i{#+QL8*8o7wJ`|eTh0WTJ9}}S#Gix`{>(^snR>K z8ip+-4V~dDj7%ZI;}tZYPMY4O{o#6c-{;BYr+CNwx|-+@70p(58U#Ps>^06r?c%$| ze=53_*%SNctKlQdKg{X)>n=W-z5!pSjB$t1gy$@zzL)xNwLibQbDH>oX@u<7H&MD9 zx#w2Q3Alzi^1c2x6w*y{_{^Al^em{}#{(GVy|~yqN+Z`5lx-AhP$z~pT5f%}2{K^r zNiL9C?bMs=Knr#n%ul9?y}vot5awwp^jPp}@rDZZuR%lI+cZ-z1Sh&QdAZ z{q1w}!N>&$qoW$?PR<8a=H5@j|0uM`Z(o*=UL0bk#_3Y?z<(ydZg4NE&$I1=wlt06 zRr-|7G)vQCg;<>Hq)p4j1vav5G~FvU>gj@*M4j?tfge;o7}A%=o6AwjZeG6m!1!c+ zf;s+8nAA!&fx3SLshHa&$t60JuP=Hj6(X(QIpVo~O6aEhS%z++zW?mhnd~uci>C43 z!E17#hx52Bf8PcB2zsJzzI{{DEPbd!{>9FVQsLUGwh;#T9QA|5&UsQ6QZ8TB+YLmA zA5}ao>ZzXKW24kxo+26082HwJbt%eu^dtI_a;a#O7M1JtyU-?|-#LSG@f_{qvUjee zO5W2-**d%J_^f1x97T2RL5I}P_|G_2Vb_V8Z%lWFr0{%lq>0ept4vYN+n_OICPwSn zvwnW--}#&|{7T}zRG&LlR|D=J%(eIi%{l7g66cg%?@>h;FnHCle(kD4g!gcCv_-aE z318PQl<3H$m&|9XKgCcq_in`Tqw>{w;Z`!6+{B8YMmY($8%UnJD)5|@bQ9%u`&rc; z;sT7P!uy3d0jZ2bB;=GX#^X0*#cAT~6$c63I(=^BN*@0Tvr8!QN;}-+$DnHXSX5-y zLQNCJLd+&Zok`*Ju=!oFG8Uhe%LfIT0nD(T45iI&D+vNg7d;$@*%r!FT&Kjm7R9!o zRVM2tz3rI$wHb=O#gcU0%>AOGyr?EI;bDTIc?~bkrZFApqbP||tNU zz=`-Yw3?|-m14()oh@rL9@s^md*_|pZ;CJPh+U3`w2$q$y?PpAx6Z8U)UhxhO2!X= zsdaRDWO`wbg^^WzI2ue~MAFPF!kWw$$y4sq>}JJ-NaROV0^3 zd|9>7I++jqIE~iI6lXv4&+0E=`w_e`cC<|O8D=jun6h&$j@8cU5u_RHYD@`r_ZZ$N z*+rFpNh=@sqBbvrr-hh)$cJc;RYg>1N*_y$P4p&?#SQ1$^p*74RQ?yGOm2LJJhg-_ zwkwzUV~ZcC{&*cw;g9#eDvI@6(wpnFj4M?mDT?o@xd|Bj%#>8_DJFa0la^Kvth%;# zBZ;M#@cK1If*6Bd4m;1a9QQ|eXm0tK|8yhGG@5mc&;BcY>}^_P;CIvI-QkKa4T>m* zwYJi0`@3)GS|idIBWcR)oWrZ@?~)r#63c5mHNkXu8Y(*zph=<6j$U6oq_18_-!(nS zz@7^+HyFgZ@+e_UohUUvy^wGO4fRh`U!*je4+V9oRATjRu9Q{umx(dduK7Lgo>w&% zb2m8Xp9%gT7?IJQUt7T<(;r%`ENu058oNI0pj0FkSMMCw#t~Z>$E^3&E8T0f*cBz6 zCFVMBwAjjY8e7-G8%ZsKZjvzBl?dJe++pQHk#5>c;txJoXq8jFk?Ua#OIIIp$3C`X zzFW3hOki>84&K(ctGVUnEKl3-dQMSvkTk8zpf2{55nmm;q=U7(qo45kwfw5-CBKLu zt$qxzEFskD*2~;CMUtaEACo0&Wc3@M~_IjFF&4FNhE*D zQqeYxnkdnJ*^KRLmk!Z+zD9!549EJO!ETS54@V)tXdZt~f2!en9K(e{Kae#k)n4vD zpR8ayimPAxtbOe65aDbJiiCJVFBa&M3D5+HamJf^P@kHW8SS!zraSvc$>jV zHblqMBPxLQG)?+Pa9ecC&5r~=&sE;eJ8a=*mantWS&Um6OW`wYq465X-mNlhzv5PW zIjlrI^+~+k=i~nDm871_YNZUEz4w@juhXgT%Ay;`#mUIt_G8_9OSCQRt2?<>T-=!aFiR5!5lU%9HbvD`Rlb64DJ(7G%N8x>bwP7JUc$&~E`-;Cd2XTV$ z0WrSnTlA~ZavVGypRNbf=%reW`SN@8lM?9o&J8pq|59V*UFBi9ROmMDuZA+8*+v`a zTwrEBI*gNhHu8ZZrj&vKGt+&Hfzm26xO>#4&x6gQx~A z9%c7vn=Q*(hVwnKNpHbV8sD%}K;_&Y8dSZN%b%o9gt5%v=(s#c_@P*hCykPunr5Uc z$D313u;gzGr??LP5VPuPQfKCk(}a$e-JcfcLaB^xyR8+YXGGU;HDpk-+?!%e81dD@ z;UQofY92q#Dx0_?erEJ?wrM|X=TPXmeUXF-uM;%+P-C2AWwn%LW&hpRgKpl_&`0g6 z@1(AM$bX)ZpeJgil^}b6%~o2kTf0n@8EalC8s7)PBlm5f}mt8s4bqxE>#dt*Z^ zLuul_C_6;N%<|-{JMG0oj2~_%o$P!&5&PDTg+0KgJMc!hz&Z1g#?5Y5cYXX0#&Dhi z7EC+)HJ{Y<$e)L=Vw1Q0z4DgK4}Pu;lB;1J%Kb2YPIYw$b7${)iO(!^(#yK1%o5DB z{40^&$!3OT_ZG~&jpnjQn9}l?lZYRba2dRMl0lFWkRY6CDENuIj_aq0hnGR6-$Vy< zm{nOpHHS~`1W&3_H|g~_EiFY1eWSS17mutN)qmm;g^lf~F6#8?qcVL&bJk+GeQ#Ux zaK^M=SY-ZY45`%M1Glh;C|%|S<1aV1Y^L3FQO+FZRMrn&)bA{(?I|ceph2B?oBQ#q zh&A}l5+ToCao_!4O7~1;YO!DE4+|}YN0=6P3~ZR5P?r)(-4Dumg-S>mF-&S#6a2cZ zxy|EzqT%EKUFnr~=Jr%a8#G`kouJWbq^>4vGPpPYm%6ZuMAE^cm?c) z?X0b=IPHb(?KlPO?1eb3?QQHid4xp-MTG76t?le={>u=W-cI0^R<8ebRmf1bFciNa zuMnRgj{ql($jd1p!Y9lrVrMVF$;;1cWzTQRYj4jdd@+=*ji`c$x0@9lr<0qNgB`c0 zyTip7h`~jrwUosf`M7xg^AjysD_?tfL7Y*|$=xsDKflm(aRxm5rm7yMrCX_rDzK-=91E9}de#fX5b$$j`}VZz}{Awzc8366A;fvl6nh z7vvY|96uAk$wNyT>opX|B(g$M-Tt6cm1!q{zn%0A3glP-u3^Pxp4oJ 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 literal 0 HcmV?d00001 From c7cecbca3f2ad0ff62589c28fdd35b68cbc75a69 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Wed, 15 Apr 2026 21:01:38 +0200 Subject: [PATCH 05/21] [graphic] plot AnalyticTraj --- .../graphics/figures/codac2_py_Figure2D.cpp | 8 ++++++++ src/graphics/figures/codac2_Figure2D.cpp | 5 +++++ src/graphics/figures/codac2_Figure2D.h | 20 +++++++++++++++++++ 3 files changed, 33 insertions(+) diff --git a/python/src/graphics/figures/codac2_py_Figure2D.cpp b/python/src/graphics/figures/codac2_py_Figure2D.cpp index e94de5de1..6545cf26f 100644 --- a/python/src/graphics/figures/codac2_py_Figure2D.cpp +++ b/python/src/graphics/figures/codac2_py_Figure2D.cpp @@ -203,6 +203,10 @@ void export_Figure2D(py::module& m) VOID_FIGURE2D_PLOT_TRAJECTORY_CONST_SAMPLEDTRAJ_DOUBLE_REF_CONST_STYLEPROPERTIES_REF, "x"_a, "style"_a=StyleProperties()) + .def("plot_trajectory", (void(Figure2D::*)(const AnalyticTraj&,const StyleProperties&))&Figure2D::plot_trajectory, + VOID_FIGURE2D_PLOT_TRAJECTORY_CONST_ANALYTICTRAJ_SCALARTYPE_REF_CONST_STYLEPROPERTIES_REF, + "x"_a, "style"_a=StyleProperties()) + .def("plot_trajectories", (void(Figure2D::*)(const SampledTraj&))&Figure2D::plot_trajectories, VOID_FIGURE2D_PLOT_TRAJECTORIES_CONST_SAMPLEDTRAJ_VECTOR_REF, "x"_a) @@ -410,6 +414,10 @@ void export_Figure2D(py::module& m) STATIC_VOID_DEFAULTFIGURE_PLOT_TRAJECTORY_CONST_SAMPLEDTRAJ_DOUBLE_REF_CONST_STYLEPROPERTIES_REF, "x"_a, "style"_a=StyleProperties()) + .def_static("plot_trajectory", (void(*)(const AnalyticTraj&,const StyleProperties&))&DefaultFigure::plot_trajectory, + STATIC_VOID_DEFAULTFIGURE_PLOT_TRAJECTORY_CONST_ANALYTICTRAJ_SCALARTYPE_REF_CONST_STYLEPROPERTIES_REF + "x"_a, "style"_a=StyleProperties()) + .def_static("plot_trajectories", (void(*)(const SampledTraj&,const StyleProperties&))&DefaultFigure::plot_trajectories, STATIC_VOID_DEFAULTFIGURE_PLOT_TRAJECTORIES_CONST_SAMPLEDTRAJ_VECTOR_REF_CONST_STYLEPROPERTIES_REF, "x"_a, "style"_a=StyleProperties()) diff --git a/src/graphics/figures/codac2_Figure2D.cpp b/src/graphics/figures/codac2_Figure2D.cpp index 0543c0b31..a1c2c5a2d 100644 --- a/src/graphics/figures/codac2_Figure2D.cpp +++ b/src/graphics/figures/codac2_Figure2D.cpp @@ -434,6 +434,11 @@ void Figure2D::plot_trajectory(const SampledTraj& x, const StyleProperti display_and_clear(); } +void Figure2D::plot_trajectory(const AnalyticTraj& x, const StyleProperties& style) +{ + plot_trajectory(x.sampled(_axes[0].limits.diam()/1e4), style); +} + void Figure2D::plot_trajectories(const SampledTraj& x) { for(const auto& xi : as_scalar_trajs(x)) diff --git a/src/graphics/figures/codac2_Figure2D.h b/src/graphics/figures/codac2_Figure2D.h index e55bcbbe7..22c6cc37e 100644 --- a/src/graphics/figures/codac2_Figure2D.h +++ b/src/graphics/figures/codac2_Figure2D.h @@ -378,6 +378,14 @@ namespace codac2 */ void plot_trajectory(const SampledTraj& x, const StyleProperties& style = StyleProperties()); + /** + * \brief Plots a trajectory on the figure (x-axis is the time) + * + * \param x AnalyticTraj to plot + * \param style Style of the trajectory (edge color) + */ + void plot_trajectory(const AnalyticTraj& x, const StyleProperties& style = StyleProperties()); + /** * \brief Plots a set of trajectories on the figure (x-axis is the time) with random colors * @@ -941,6 +949,18 @@ namespace codac2 selected_fig()->plot_trajectory(x,style); } + /** + * \brief Plots a trajectory on the figure (x-axis is the time) + * + * \param x AnalyticTraj to plot + * \param style Style of the trajectory (edge color) + */ + static void plot_trajectory(const AnalyticTraj& x, const StyleProperties& style = StyleProperties()) + { + auto_init(); + selected_fig()->plot_trajectory(x,style); + } + /** * \brief Plots a set of trajectories on the figure (x-axis is the time) * From 8e513b2ff91da794d3dbcf575248418455c820fa Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Wed, 15 Apr 2026 21:01:56 +0200 Subject: [PATCH 06/21] [tube] improvements on tubes --- python/codac/core/__init__.py | 8 +- python/src/codac2_py_matlab.h | 6 +- .../interval/codac2_py_IntervalMatrixBase.h | 32 +- .../domains/tube/codac2_py_SlicedTube.cpp | 332 +++++++----------- src/core/domains/tube/codac2_SlicedTube.h | 218 +++++++++--- .../tube/codac2_SlicedTube_operations.h | 44 +++ 6 files changed, 353 insertions(+), 287 deletions(-) diff --git a/python/codac/core/__init__.py b/python/codac/core/__init__.py index 7e528dae9..a840c9d31 100644 --- a/python/codac/core/__init__.py +++ b/python/codac/core/__init__.py @@ -335,16 +335,16 @@ def SlicedTube(x, y=None): y = AnalyticFunction(y) if isinstance(y, _ANALYTIC_FUNCTION_TYPES) else y - if isinstance(y, (Interval, AnalyticFunction_Scalar, SampledTraj_Scalar)): + if isinstance(y, (Interval, AnalyticFunction_Scalar, AnalyticTraj_Scalar, SampledTraj_Scalar)): return SlicedTube_Interval(x, y) - if isinstance(y, (IntervalVector, AnalyticFunction_Vector, SampledTraj_Vector)): + if isinstance(y, (IntervalVector, AnalyticFunction_Vector, AnalyticTraj_Vector, SampledTraj_Vector)): return SlicedTube_IntervalVector(x, y) - if isinstance(y, (IntervalMatrix, AnalyticFunction_Matrix, SampledTraj_Matrix)): + if isinstance(y, (IntervalMatrix, AnalyticFunction_Matrix, AnalyticTraj_Matrix, SampledTraj_Matrix)): return SlicedTube_IntervalMatrix(x, y) - codac_error("SlicedTube: can only build this tube from an AnalyticFunction_[Scalar/Vector/Matrix]") + codac_error("SlicedTube: wrong constructor argument") def fixpoint(contract, *x): diff --git a/python/src/codac2_py_matlab.h b/python/src/codac2_py_matlab.h index 9c53edb48..4eb477b53 100644 --- a/python/src/codac2_py_matlab.h +++ b/python/src/codac2_py_matlab.h @@ -42,7 +42,7 @@ namespace codac2 } template - Index input_index(const I& x) + Index_type input_index(const I& x) { if constexpr(FOR_MATLAB) return x-1; @@ -61,11 +61,11 @@ namespace codac2 { if constexpr(FOR_MATLAB) { - std::vector indices_(indices.size()); + std::vector indices_(indices.size()); for(size_t i = 0 ; i < indices.size() ; i++) { matlab::test_integer(indices[i]); - indices_[i] = (Index)matlab::input_index(indices[i]); + indices_[i] = (Index_type)matlab::input_index(indices[i]); } return indices_; diff --git a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h index a5da22274..b31f9d7f5 100644 --- a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h +++ b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h @@ -70,61 +70,61 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) .def("diam", [](const S& x) { return x.diam(); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_AUTO_DIAM_CONST) - .def("min_rad", [](const S& x, const std::vector& among_indices) + .def("min_rad", [](const S& x, const std::vector& among_indices) { return x.min_rad( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_RAD_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("max_rad", [](const S& x, const std::vector& among_indices) + .def("max_rad", [](const S& x, const std::vector& among_indices) { return x.max_rad( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_RAD_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("min_diam", [](const S& x, const std::vector& among_indices) + .def("min_diam", [](const S& x, const std::vector& among_indices) { return x.min_diam( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MIN_DIAM_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("max_diam", [](const S& x, const std::vector& among_indices) + .def("max_diam", [](const S& x, const std::vector& among_indices) { return x.max_diam( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_DOUBLE_MAX_DIAM_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("min_diam_index", [](const S& x, const std::vector& among_indices) + .def("min_diam_index", [](const S& x, const std::vector& among_indices) { return matlab::output_index(x.min_diam_index( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MIN_DIAM_INDEX_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("max_diam_index", [](const S& x, const std::vector& among_indices) + .def("max_diam_index", [](const S& x, const std::vector& among_indices) { return matlab::output_index(x.max_diam_index( among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_MAX_DIAM_INDEX_CONST_VECTOR_INDEX_REF_CONST, - "among_indices"_a=std::vector()) + "among_indices"_a=std::vector()) - .def("extr_diam_index", [](const S& x, bool min, const std::vector& among_indices) + .def("extr_diam_index", [](const S& x, bool min, const std::vector& among_indices) { return matlab::output_index(x.extr_diam_index(min, among_indices.empty() ? among_indices : matlab::convert_indices(among_indices))); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_INDEX_EXTR_DIAM_INDEX_BOOL_CONST_VECTOR_INDEX_REF_CONST, - "min"_a, "among_indices"_a=std::vector()) + "min"_a, "among_indices"_a=std::vector()) .def("__contains__", [](const S& x, const V& y) { return x.contains(y); }, MATRIXBASE_ADDONS_INTERVALMATRIXBASE_BOOL_CONTAINS_CONST_MATRIXBASE_OTHERDERIVED_REF_CONST) @@ -194,13 +194,13 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) "i"_a, "ratio"_a = 0.49) .def("bisect_largest", - [](const S& x, double ratio, const std::vector& among_indices) + [](const S& x, double ratio, const std::vector& among_indices) { return x.bisect_largest(ratio, among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_LARGEST_FLOAT_CONST_VECTOR_INDEX_REF_CONST, - "ratio"_a = 0.49, "among_indices"_a=std::vector()) + "ratio"_a = 0.49, "among_indices"_a=std::vector()) ; if constexpr(!FOR_MATLAB) diff --git a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp b/python/src/core/domains/tube/codac2_py_SlicedTube.cpp index c131a5096..19c9eef08 100644 --- a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp +++ b/python/src/core/domains/tube/codac2_py_SlicedTube.cpp @@ -41,6 +41,10 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICFUNCTION_TYPENAME_EXPRTYPE_T_TYPE_REF, "tdomain"_a, "f"_a) + .def(py::init&,const AnalyticTraj::Type>&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICTRAJ_TYPENAME_EXPRTYPE_T_TYPE_REF, + "tdomain"_a, "x"_a) + .def(py::init&,const SampledTraj::Type::Scalar>&>(), SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_SAMPLEDTRAJ_V_REF, "tdomain"_a, "x"_a) @@ -107,21 +111,6 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: PAIR_TT_SLICEDTUBE_T_ENCLOSED_BOUNDS_CONST_INTERVAL_REF_CONST, "t"_a) - .def("invert", (Interval (SlicedTube::*)(const T&,const Interval&) const) &SlicedTube::invert, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "t"_a=Interval()) - - .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const Interval& t) - { - vector vector_t; - x.invert(y, vector_t, t); - v_t.clear(); - for(const auto& ti : vector_t) - v_t.append(ti); - }, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v_t"_a, "t"_a=Interval()) - .def("set", (void (SlicedTube::*)(const T&)) &SlicedTube::set, VOID_SLICEDTUBE_T_SET_CONST_T_REF, "codomain"_a) @@ -230,21 +219,65 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: SLICEDTUBE_T_SLICEDTUBE_T_PRIMITIVE_CONST_T_REF_CONST, "x0"_a) + .def("invert", (Interval (SlicedTube::*)(const T&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST, + "y"_a) + .def("invert", (Interval (SlicedTube::*)(const T&,const Interval&) const) &SlicedTube::invert, INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "t"_a=Interval()) + "y"_a, "t"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t) + { + vector vector_t; + x.invert(y, vector_t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST, + "y"_a, "v_t"_a) - .def("invert", (void (SlicedTube::*)(const T&,std::vector&,const Interval&) const) &SlicedTube::invert, + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const Interval& t) + { + vector vector_t; + x.invert(y, vector_t, t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v_t"_a, "t"_a=Interval()) + "y"_a, "v_t"_a, "t"_a) + + .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST, + "y"_a, "v"_a) .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&,const Interval&) const) &SlicedTube::invert, INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v"_a, "t"_a=Interval()) + "y"_a, "v"_a, "t"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v) + { + vector vector_t; + x.invert(y, vector_t, v); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST, + "y"_a, "v_t"_a, "v"_a) - .def("invert", (void (SlicedTube::*)(const T&,std::vector&,const SlicedTube&,const Interval&) const) &SlicedTube::invert, + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v, const Interval& t) + { + vector vector_t; + x.invert(y, vector_t, v, t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v_t"_a, "v"_a, "t"_a=Interval()) + "y"_a, "v_t"_a, "v"_a, "t"_a) .def("mid", &SlicedTube::mid, SAMPLEDTRAJ_TYPENAME_SCALAR_T_TYPE_SLICEDTUBE_T_MID_CONST); @@ -305,53 +338,98 @@ py::class_,TubeBase> _export_SlicedTube(py::module& m, const std:: template void add_tube_operators(py::class_,TubeBase>& pyclass) { + if constexpr(!FOR_MATLAB) + { + pyclass + + .def(py::self & py::self, + SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def(py::self &= py::self, + SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def(py::self | py::self, + SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def(py::self |= py::self, + SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + ; + } + + if constexpr(FOR_MATLAB) + { + // For MATLAB compatibility + pyclass + + .def("inter", &SlicedTube::operator&, + SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("self_inter", &SlicedTube::operator&=, + SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("union", &SlicedTube::operator|, + SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("self_union", &SlicedTube::operator|=, + SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + ; + } + pyclass - .def("__add__", [](py::object& x1) { return cast>(x1); }, + .def("__add__", (const SlicedTube&(*)(const SlicedTube&)) &codac2::operator+, CONST_SLICEDTUBE_T_REF_OPERATORPLUS_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__add__", [](py::object& x1, py::object& x2) { return cast>(x1)+cast>(x2); }, + .def("__add__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator+, SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__add__", [](py::object& x1, const T& x2) { return cast>(x1)+x2; }, + .def("__add__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator+, SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, py::is_operator()) - .def("__radd__", [](py::object& x2, const T& x1) { return x1+cast>(x2); }, + .def("__radd__", (SlicedTube(*)(const T&,const SlicedTube&)) &codac2::operator+, SLICEDTUBE_T_OPERATORPLUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__sub__", [](py::object& x1) { return -cast>(x1); }, + .def("__sub__", (SlicedTube(*)(const SlicedTube&)) &codac2::operator-, SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__sub__", [](py::object& x1, py::object& x2) { return cast>(x1)-cast>(x2); }, + .def("__sub__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator-, SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__sub__", [](py::object& x1, const T& x2) { return cast>(x1)-x2; }, + .def("__sub__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator-, SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, py::is_operator()) - .def("__rsub__", [](py::object& x2, const T& x1) { return x1-cast>(x2); }, + .def("__rsub__", (SlicedTube(*)(const T&,const SlicedTube&)) &codac2::operator-, SLICEDTUBE_T_OPERATORMINUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__mul__", [](py::object& x1, const Interval& x2) { return x2*cast>(x1); }, + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF, py::is_operator()) - .def("__rmul__", [](py::object& x2, const Interval& x1) { return x1*cast>(x2); }, + .def("__rmul__", (SlicedTube(*)(const Interval&,const SlicedTube&)) &codac2::operator*, SLICEDTUBE_T_OPERATORMUL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__mul__", [](const Interval& x1, py::object& x2) { return x1*cast>(x2); }, + .def("__mul__", (SlicedTube(*)(const Interval&,const SlicedTube&)) &codac2::operator*, SLICEDTUBE_T_OPERATORMUL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) - .def("__truediv__", [](py::object& x1, const Interval& x2) { return cast>(x1)/x2; }, + .def("__truediv__", (SlicedTube(*)(const SlicedTube&,const Interval&)) &codac2::operator/, SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, py::is_operator()) ; @@ -368,6 +446,14 @@ void export_SlicedTube(py::module& m) py_SlicedTube_Interval + .def(py::self | py::self, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def(py::self & py::self, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def(py::self * py::self, SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, py::is_operator()) @@ -526,182 +612,4 @@ void export_SlicedTube(py::module& m) "x1"_a, py::is_operator()) ; -} - - - -#if 0 - -// Keeping the following just in case... -// Equivalent to the previous block of code, but using py::object for tubes - -void export_SlicedTube(py::module& m) -{ - auto py_SlicedTube_Interval = _export_SlicedTube(m, "SlicedTube_Interval"); - auto py_SlicedTube_IntervalVector = _export_SlicedTube(m, "SlicedTube_IntervalVector"); - auto py_SlicedTube_IntervalMatrix = _export_SlicedTube(m, "SlicedTube_IntervalMatrix"); - - add_tube_operators(py_SlicedTube_Interval); - - py_SlicedTube_Interval - - .def(py::self * py::self, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self / py::self, - SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(double() / py::self, - SLICEDTUBE_T_OPERATORDIV_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - ; - - add_tube_operators(py_SlicedTube_IntervalMatrix); - add_tube_operators(py_SlicedTube_IntervalVector); - py_SlicedTube_IntervalMatrix - - .def("__mul__", [](py::object& x1, py::object& x2) { return cast>(x1)*cast>(x2); }, - SLICEDTUBE_INTERVALVECTOR_OPERATORMUL_CONST_SLICEDTUBE_INTERVALMATRIX_REF_CONST_SLICEDTUBE_INTERVALVECTOR_REF, - py::is_operator()) - - .def("__mul__", [](py::object& x1, py::object& x2) { return cast>(x1)*cast>(x2); }, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - ; - - m - - .def("sqr", [](py::object& x1) { return codac2::sqr(cast>(x1)); }, - SLICEDTUBE_INTERVAL_SQR_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sqrt", [](py::object& x1) { return codac2::sqrt(cast>(x1)); }, - SLICEDTUBE_INTERVAL_SQRT_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("pow", [](py::object& x1, const Interval& x2) { return codac2::pow(cast>(x1),x2); }, - SLICEDTUBE_INTERVAL_POW_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - //.def("root", (SlicedTube (*)(const SlicedTube&,int)) &codac2::root, - // SAMPLEDTRAJ_DOUBLE_ROOT_CONST_SAMPLEDTRAJ_DOUBLE_REF_INT, - // "x1"_a, "x2"_a, py::is_operator()) - - .def("exp", [](py::object& x1) { return codac2::exp(cast>(x1)); }, - SLICEDTUBE_INTERVAL_EXP_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("log", [](py::object& x1) { return codac2::log(cast>(x1)); }, - SLICEDTUBE_INTERVAL_LOG_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("cos", [](py::object& x1) { return codac2::cos(cast>(x1)); }, - SLICEDTUBE_INTERVAL_COS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sin", [](py::object& x1) { return codac2::sin(cast>(x1)); }, - SLICEDTUBE_INTERVAL_SIN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("tan", [](py::object& x1) { return codac2::tan(cast>(x1)); }, - SLICEDTUBE_INTERVAL_TAN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("acos", [](py::object& x1) { return codac2::acos(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ACOS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("asin", [](py::object& x1) { return codac2::asin(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ASIN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atan", [](py::object& x1) { return codac2::atan(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ATAN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atan2", [](py::object& x1, py::object& x2) { return codac2::atan2(cast>(x1),cast>(x2)); }, - SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("atan2", [](py::object& x1, const Interval& x2) { return codac2::atan2(cast>(x1),x2); }, - SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("atan2", [](const Interval& x1, py::object& x2) { return codac2::atan2(x1,cast>(x2)); }, - SLICEDTUBE_INTERVAL_ATAN2_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("cosh", [](py::object& x1) { return codac2::cosh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_COSH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sinh", [](py::object& x1) { return codac2::sinh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_SINH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("tanh", [](py::object& x1) { return codac2::tanh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_TANH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("acosh", [](py::object& x1) { return codac2::acosh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ACOSH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("asinh", [](py::object& x1) { return codac2::asinh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ASINH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atanh", [](py::object& x1) { return codac2::atanh(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ATANH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("abs", [](py::object& x1) { return codac2::abs(cast>(x1)); }, - SLICEDTUBE_INTERVAL_ABS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("min", [](py::object& x1, py::object& x2) { return codac2::min(cast>(x1),cast>(x2)); }, - SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("min", [](py::object& x1, const Interval& x2) { return codac2::min(cast>(x1),x2); }, - SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("min", [](const Interval& x1, py::object& x2) { return codac2::min(x1,cast>(x2)); }, - SLICEDTUBE_INTERVAL_MIN_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", [](py::object& x1, py::object& x2) { return codac2::max(cast>(x1),cast>(x2)); }, - SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", [](py::object& x1, const Interval& x2) { return codac2::max(cast>(x1),x2); }, - SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", [](const Interval& x1, py::object& x2) { return codac2::max(x1,cast>(x2)); }, - SLICEDTUBE_INTERVAL_MAX_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("sign", [](py::object& x1) { return codac2::sign(cast>(x1)); }, - SLICEDTUBE_INTERVAL_SIGN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("integer", [](py::object& x1) { return codac2::integer(cast>(x1)); }, - SLICEDTUBE_INTERVAL_INTEGER_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("floor", [](py::object& x1) { return codac2::floor(cast>(x1)); }, - SLICEDTUBE_INTERVAL_FLOOR_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("ceil", [](py::object& x1) { return codac2::ceil(cast>(x1)); }, - SLICEDTUBE_INTERVAL_CEIL_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - ; -} -#endif \ No newline at end of file +} \ No newline at end of file diff --git a/src/core/domains/tube/codac2_SlicedTube.h b/src/core/domains/tube/codac2_SlicedTube.h index a26b8fa9a..881158e2f 100644 --- a/src/core/domains/tube/codac2_SlicedTube.h +++ b/src/core/domains/tube/codac2_SlicedTube.h @@ -14,6 +14,7 @@ #include "codac2_Tube_operator.h" #include "codac2_CtcDeriv.h" #include "codac2_Scalar.h" +#include "codac2_AnalyticTraj.h" namespace codac2 { @@ -77,23 +78,43 @@ namespace codac2 }); } + /** + * \brief Creates a sliced tube by evaluating an analytic trajectory on each temporal slice + * + * The function is evaluated on each temporal interval of the associated + * ``TDomain``. + * + * \param tdomain shared temporal domain of the tube + * \param x analytic trajectory + */ + explicit SlicedTube(const std::shared_ptr& tdomain, + const AnalyticTraj::Type>& x) + : SlicedTubeBase(tdomain) + { + for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it) + it->_slices.insert({ + this, + std::make_shared>(*this, it, x.eval((Interval)*it)) + }); + } + /** * \brief Creates a sliced tube from a sampled trajectory * * \tparam V sampled value type * \param tdomain shared temporal domain of the tube - * \param f sampled trajectory evaluated on each temporal slice + * \param x sampled trajectory evaluated on each temporal slice */ template requires std::is_same_v::Domain,T> explicit SlicedTube(const std::shared_ptr& tdomain, - const SampledTraj& f) + const SampledTraj& x) : SlicedTubeBase(tdomain) { for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it) it->_slices.insert({ this, - std::make_shared>(*this, it, f((Interval)*it)) + std::make_shared>(*this, it, x((Interval)*it)) }); } @@ -656,6 +677,12 @@ namespace codac2 }; } + // Inversion related methods + + /** + * \defgroup codac2_slicedtube_inversion Inversion of sliced tubes + */ + template Interval invert_common(const T& y, const Interval& t, const Func& apply_invert) const { @@ -728,15 +755,29 @@ namespace codac2 } /** - * \brief Returns the interval inversion \f$[x]^{-1}([y])\f$ + * \brief Returns the interval inversion \f$[x]^{-1}([y])\f$. * - * \note If the inversion results in several pre-images, their union is returned + * If the inversion results in several pre-images, their union is returned. * * \param y interval codomain - * \param t optional temporal domain on which the inversion will be performed * \return the hull of \f$[x]^{-1}([y])\f$ */ - Interval invert(const T& y, const Interval& t = Interval()) const + Interval invert(const T& y) const + { + return invert(y,t0_tf()); + } + + /** + * \ingroup codac2_slicedtube_inversion + * \brief Returns the interval inversion \f$[x]^{-1}([y])\f$. + * + * If the inversion results in several pre-images, their union is returned. + * + * \param y interval codomain + * \param t (optional) temporal domain on which the inversion will be performed + * \return the hull of \f$[x]^{-1}([y])\f$ + */ + Interval invert(const T& y, const Interval& t) const { return invert_common(y, t, [this,&y](auto it, const Interval& t_) { @@ -745,14 +786,27 @@ namespace codac2 } /** - * \brief Computes the set of continuous values of the inversion \f$[x]^{-1}([y])\f$ + * \brief Computes the set of continuous values of the inversion \f$[x]^{-1}([y])\f$. + * + * \param y interval codomain + * \param v_t vector of the sub-tdomains \f$[t_k]\f$ for which + * \f$\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot)\f$ + */ + void invert(const T& y, std::vector &v_t) const + { + invert(y,v_t,t0_tf()); + } + + /** + * \ingroup codac2_slicedtube_inversion + * \brief Computes the set of continuous values of the inversion \f$[x]^{-1}([y])\f$. * * \param y interval codomain * \param v_t vector of the sub-tdomains \f$[t_k]\f$ for which * \f$\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot)\f$ - * \param t optional temporal domain on which the inversion will be performed + * \param t (optional) temporal domain on which the inversion will be performed */ - void invert(const T& y, std::vector &v_t, const Interval& t = Interval()) const + void invert(const T& y, std::vector &v_t, const Interval& t) const { return invert_common_subsets(y, v_t, t, [this,&y](auto it, const Interval& t_) { @@ -761,17 +815,34 @@ namespace codac2 } /** - * \brief Returns the optimal interval inversion \f$[x]^{-1}([y])\f$ + * \brief Returns the optimal interval inversion \f$[x]^{-1}([y])\f$. + * + * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows a finer inversion. + * If the inversion results in several pre-images, their union is returned. + * + * \param y interval codomain + * \param v derivative tube such that \f$\dot{x}(\cdot)\in[v](\cdot)\f$ + * \return hull of \f$[x]^{-1}([y])\f$ + */ + Interval invert(const T& y, const SlicedTube& v) const + requires (std::is_same_v || std::is_same_v) + { + return invert(y,v,t0_tf()); + } + + /** + * \ingroup codac2_slicedtube_inversion + * \brief Returns the optimal interval inversion \f$[x]^{-1}([y])\f$. * - * \note The knowledge of the derivative tube \f$[v](\cdot)\f$ allows a finer inversion - * \note If the inversion results in several pre-images, their union is returned + * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows a finer inversion. + * If the inversion results in several pre-images, their union is returned. * * \param y interval codomain * \param v derivative tube such that \f$\dot{x}(\cdot)\in[v](\cdot)\f$ - * \param t optional temporal domain on which the inversion will be performed + * \param t (optional) temporal domain on which the inversion will be performed * \return hull of \f$[x]^{-1}([y])\f$ */ - Interval invert(const T& y, const SlicedTube& v, const Interval& t = Interval()) const + Interval invert(const T& y, const SlicedTube& v, const Interval& t) const requires (std::is_same_v || std::is_same_v) { return invert_common(y, t, @@ -781,17 +852,34 @@ namespace codac2 } /** - * \brief Computes the set of continuous values of the optimal inversion \f$[x]^{-1}([y])\f$ + * \brief Computes the set of continuous values of the optimal inversion \f$[x]^{-1}([y])\f$. * - * \note The knowledge of the derivative tube \f$[v](\cdot)\f$ allows finer inversions + * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows finer inversions. * * \param y interval codomain * \param v_t vector of the sub-tdomains \f$[t_k]\f$ for which - * \f$\exists t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot), \dot{x}(\cdot)\in[v](\cdot)\f$ + * \f$\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot), \dot{x}(\cdot)\in[v](\cdot)\f$ * \param v derivative tube such that \f$\dot{x}(\cdot)\in[v](\cdot)\f$ - * \param t optional temporal domain on which the inversion will be performed */ - void invert(const T& y, std::vector &v_t, const SlicedTube& v, const Interval& t = Interval()) const + void invert(const T& y, std::vector &v_t, const SlicedTube& v) const + requires (std::is_same_v || std::is_same_v) + { + invert(y,v_t,v,t0_tf()); + } + + /** + * \ingroup codac2_slicedtube_inversion + * \brief Computes the set of continuous values of the optimal inversion \f$[x]^{-1}([y])\f$. + * + * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows finer inversions. + * + * \param y interval codomain + * \param v_t vector of the sub-tdomains \f$[t_k]\f$ for which + * \f$\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot), \dot{x}(\cdot)\in[v](\cdot)\f$ + * \param v derivative tube such that \f$\dot{x}(\cdot)\in[v](\cdot)\f$ + * \param t (optional) temporal domain on which the inversion will be performed + */ + void invert(const T& y, std::vector &v_t, const SlicedTube& v, const Interval& t) const requires (std::is_same_v || std::is_same_v) { return invert_common_subsets(y, v_t, t, @@ -803,90 +891,115 @@ namespace codac2 // Integral related methods /** - * \brief Returns an enclosure of the integral of this tube from \f$t_0\f$ to \f$[t]\f$ + * \defgroup codac2_slicedtube_integrals Integration and primitive operations on sliced tubes + * \brief The following methods are valid for tubes defined for ``Interval`` or + * ``IntervalVector`` codomains. The returned values are integral enclosures of + * same type (respectively, ``Interval`` or ``IntervalVector``). + */ + + /** + * \ingroup codac2_slicedtube_integrals + * \brief Returns an enclosure of the integrals of this tube from \f$t_0\f$ to \f$[t]\f$. * * This method computes an enclosure of * \f[ - * \left\{ \int_{t_0}^{\tau} x(s)\,ds \;\middle|\; \tau\in[t] \right\}. + * \left\{ \int_{t_0}^{\tau} [x](s)\,ds \;\middle|\; \tau\in[t] \right\}. * \f] * * It is obtained from ``partial_integral(t)`` by taking the hull between * the lower bound of the lower enclosure and the upper bound of the upper * enclosure. * - * \param t temporal interval - * \return enclosure of the partial integral of this tube over ``t`` + * \param t temporal interval \f$[t]\f$ + * \return enclosure of the integrals of this tube over ``t`` */ T integral(const Interval& t) const; /** - * \brief Returns an enclosure of the integral of this tube between \f$[t_1]\f$ and \f$[t_2]\f$ + * \ingroup codac2_slicedtube_integrals + * \brief Returns an enclosure of the integrals of this tube between the + * time intervals\f$[t_1]\f$ and \f$[t_2]\f$. * * This method computes an enclosure of * \f[ - * \left\{ \int_{\tau_1}^{\tau_2} x(s)\,ds + * \left\{ \int_{\tau_1}^{\tau_2} [x](s)\,ds * \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] \right\}. * \f] * * The result is obtained by subtracting the partial integral enclosures at * ``t1`` and ``t2``. * - * \param t1 first temporal interval - * \param t2 second temporal interval - * \return enclosure of the integral of this tube between ``t1`` and ``t2`` + * \param t1 first temporal interval \f$[t_1]\f$ + * \param t2 second temporal interval \f$[t_2]\f$ + * \return enclosure of the integrals of this tube between ``t1`` and ``t2`` */ T integral(const Interval& t1, const Interval& t2) const; /** - * \brief Returns lower and upper enclosures of the primitive of this tube over \f$[t]\f$ + * \ingroup codac2_slicedtube_integrals + * \brief Returns lower and upper enclosures of the integrals of this tube + * \f$[x](\cdot)=[x^-(\cdot),x^+(\cdot)]\f$ from \f$t_0\f$ to \f$[t]\f$. * - * This method returns a pair ``(p⁻,p⁺)`` such that, for every - * \f$\tau\in[t]\f$, + * This method returns a pair \f$([p^-],[p^+])\f$ such that: * \f[ - * \int_{t_0}^{\tau} x(s)\,ds \in [\,p^-,\,p^+\,]. + * [p^-]\supset + * \left\{ \int_{t_0}^{\tau} x^-(s)\,ds + * \;\middle|\; \tau\in[t] + * \right\} + * \mathrm{~~and~~} + * [p^+]\supset + * \left\{\int_{t_0}^{\tau} x^+(s)\,ds + * \;\middle|\; \tau\in[t] + * \right\}. * \f] * - * More precisely: - * - ``first`` encloses the lower bounds of the partial integrals, - * - ``second`` encloses the upper bounds of the partial integrals. - * * This representation preserves more information than ``integral(t)``, * which only returns the hull of these partial integral bounds. * - * \param t temporal interval + * \param t temporal interval \f$[t]\f$ * \return pair of lower and upper partial integral enclosures over ``t`` */ std::pair partial_integral(const Interval& t) const; /** - * \brief Returns lower and upper enclosures of the primitive increment between \f$[t_1]\f$ and \f$[t_2]\f$ + * \ingroup codac2_slicedtube_integrals + * \brief Returns lower and upper enclosures of the integrals of this tube + * \f$[x](\cdot)=[x^-(\cdot),x^+(\cdot)]\f$ between \f$[t_1]\f$ and \f$[t_2]\f$. * * This method returns a pair obtained by subtracting the partial integral - * enclosures at ``t1`` from those at ``t2``. - * - * It provides lower and upper enclosures of + * enclosures at ``t1`` from those at ``t2``. The returned pair \f$([p^-],[p^+])\f$ + * is such that: + * \f[ + * [p^-]\supset + * \left\{ \int_{\tau_1}^{\tau_2} x^-(s)\,ds + * \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] + * \right\}, + * \f] + * and * \f[ - * \int_{\tau_1}^{\tau_2} x(s)\,ds, - * \qquad \tau_1\in[t_1],\ \tau_2\in[t_2]. + * [p^+]\supset + * \left\{\int_{\tau_1}^{\tau_2} x^+(s)\,ds + * \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] + * \right\}. * \f] * - * \param t1 first temporal interval - * \param t2 second temporal interval - * \return pair of lower and upper enclosures of the integral increment + * \param t1 first temporal interval \f$[t_1]\f$ + * \param t2 second temporal interval \f$[t_2]\f$ + * \return pair of lower and upper enclosures of the integrals */ std::pair partial_integral(const Interval& t1, const Interval& t2) const; /** - * \brief Returns a primitive of this tube with zero initial condition + * \ingroup codac2_slicedtube_integrals + * \brief Returns a primitive of this tube with zero initial condition. * * This is a shorthand for ``primitive(x0)`` with \f$x_0 = 0\f$. * - * The returned tube ``p`` is defined on the same temporal domain and - * satisfies the derivative relation + * In other words, the returned tube encloses solutions of * \f[ * \dot{p}(\cdot) \in [x](\cdot), + * \qquad p(t_0)=0. * \f] - * together with the initial condition \f$p(t_0)=0\f$. * * \return primitive tube with zero initial condition */ @@ -898,11 +1011,12 @@ namespace codac2 } /** + * \ingroup codac2_slicedtube_integrals * \brief Returns a primitive of this tube with prescribed initial condition * * This method constructs a tube ``p`` on the same temporal domain as this * tube, imposes the initial condition \f$p(t_0)=x_0\f$, and contracts - * ``p`` with ``*this`` through the derivative relation using ``CtcDeriv``. + * ``p`` with this tube through the derivative relation using ``CtcDeriv``. * * In other words, the returned tube encloses solutions of * \f[ diff --git a/src/core/domains/tube/codac2_SlicedTube_operations.h b/src/core/domains/tube/codac2_SlicedTube_operations.h index a5c201cf5..1ad9c04c6 100644 --- a/src/core/domains/tube/codac2_SlicedTube_operations.h +++ b/src/core/domains/tube/codac2_SlicedTube_operations.h @@ -80,6 +80,12 @@ namespace codac2 return x1; \ } \ + template + inline T operator_tube_union(const T& x1, const T& x2) { return x1 | x2; } + + template + inline T operator_tube_intersection(const T& x1, const T& x2) { return x1 & x2; } + template inline T operator_tube_add(const X1& x1, const X2& x2) { return x1 + x2; } @@ -104,6 +110,44 @@ namespace codac2 template inline T operator_tube_div_scal(const X1& x1, const Interval& x2) { return x1 / x2; } + /** + * \brief Operates |= + * \param x1 + * \param x2 + * \return updated output + */ + template + inline SlicedTube& operator|=(SlicedTube& x1, const SlicedTube& x2) + macro_member_binary_tube_tube(operator_tube_union); + + /** \brief \f$[x_1](\cdot)\scup[x_2](\cdot)\f$ + * \param x1 + * \param x2 + * \return tube output + */ + template + inline SlicedTube operator|(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_union); + + /** + * \brief Operates &= + * \param x1 + * \param x2 + * \return updated output + */ + template + inline SlicedTube& operator&=(SlicedTube& x1, const SlicedTube& x2) + macro_member_binary_tube_tube(operator_tube_intersection); + + /** \brief \f$[x_1](\cdot)\cap[x_2](\cdot)\f$ + * \param x1 + * \param x2 + * \return tube output + */ + template + inline SlicedTube operator&(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_intersection); + /** \brief \f$x1(\cdot)\f$ * \param x1 * \return tube output From b8df740b0e15df403f846201c8125e74033fbb13 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 09:01:49 +0200 Subject: [PATCH 07/21] [traj] resolve TrajBase/SampledTraj circular dependency --- .../src/core/trajectory/codac2_py_TrajBase.h | 2 +- src/core/trajectory/codac2_TrajBase.h | 70 ++-------------- src/core/trajectory/codac2_TrajBase_impl.h | 82 +++++++++++++++++++ 3 files changed, 90 insertions(+), 64 deletions(-) create mode 100644 src/core/trajectory/codac2_TrajBase_impl.h diff --git a/python/src/core/trajectory/codac2_py_TrajBase.h b/python/src/core/trajectory/codac2_py_TrajBase.h index d5a5e3951..7802cf6f5 100644 --- a/python/src/core/trajectory/codac2_py_TrajBase.h +++ b/python/src/core/trajectory/codac2_py_TrajBase.h @@ -70,7 +70,7 @@ void export_TrajBase(py::class_& pyclass) { return x.sampled(dt); }, - VIRTUAL_SAMPLEDTRAJ_T_TRAJBASE_T_SAMPLED_DOUBLE_CONST, + SAMPLEDTRAJ_T_TRAJBASE_T_SAMPLED_DOUBLE_CONST, "dt"_a) .def("sampled_as", [](const S& this_traj, const SampledTraj& x) diff --git a/src/core/trajectory/codac2_TrajBase.h b/src/core/trajectory/codac2_TrajBase.h index b72d54faa..3abb4027a 100644 --- a/src/core/trajectory/codac2_TrajBase.h +++ b/src/core/trajectory/codac2_TrajBase.h @@ -36,69 +36,13 @@ namespace codac2 virtual T operator()(double t) const = 0; virtual typename Wrapper::Domain operator()(const Interval& t) const = 0; - auto nan_value() const - { - if constexpr(std::is_same_v || std::is_same_v::Type,ScalarType>) - return std::numeric_limits::quiet_NaN(); - - else - return T((*this)(tdomain().lb())) // we obtain the output dimension by an evalution... - .init(std::numeric_limits::quiet_NaN()); - } - - virtual SampledTraj sampled(double dt) const - { - assert_release(dt > 0.); - assert_release(!is_empty()); - - auto tdom = tdomain(); - SampledTraj straj; - for(double t = tdom.lb() ; t < tdom.ub() ; t+=dt) - straj.set((*this)(t), t); - straj.set((*this)(tdom.ub()), tdom.ub()); - return straj; - } - + // Implementation in codac2_TrajBase_impl.h + auto nan_value() const; + virtual SampledTraj sampled(double dt) const; template - SampledTraj sampled_as(const SampledTraj& x) const - { - assert_release(x.tdomain().is_subset(this->tdomain())); - - SampledTraj straj; - for(const auto& [ti,dump] : x) - straj.set((*this)(ti), ti); - return straj; - } - - SampledTraj primitive(double dt) const - { - assert_release(dt > 0.); - assert_release(!is_empty()); - - T s = [this]() { - if constexpr(std::is_same_v) - return 0.; - else - return T((*this)(this->tdomain().lb())).init(0.); - }(); - - SampledTraj p; - double t = tdomain().lb(), last_t = t; - p.set(s, t); t += dt; - - while(t < tdomain().ub()) - { - s += ((*this)(last_t)+(*this)(t))*dt/2.; - p.set(s, t); - last_t = t; - t += dt; - } - - t = tdomain().ub(); - s += ((*this)(last_t)+(*this)(t))*(t-last_t)/2.; - p.set(s, t); - - return p; - } + SampledTraj sampled_as(const SampledTraj& x) const; + SampledTraj primitive(double dt) const; }; } + +#include "codac2_TrajBase_impl.h" \ No newline at end of file diff --git a/src/core/trajectory/codac2_TrajBase_impl.h b/src/core/trajectory/codac2_TrajBase_impl.h new file mode 100644 index 000000000..50d123e78 --- /dev/null +++ b/src/core/trajectory/codac2_TrajBase_impl.h @@ -0,0 +1,82 @@ +/** + * \file codac2_TrajBase_impl.h + * ---------------------------------------------------------------------------- + * \date 2024 + * \author Simon Rohou + * \copyright Copyright 2024 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#pragma once + +namespace codac2 +{ + template + auto TrajBase::nan_value() const + { + if constexpr(std::is_same_v || std::is_same_v::Type,ScalarType>) + return std::numeric_limits::quiet_NaN(); + + else + return T((*this)(tdomain().lb())) // we obtain the output dimension by an evalution... + .init(std::numeric_limits::quiet_NaN()); + } + + template + SampledTraj TrajBase::sampled(double dt) const + { + assert_release(dt > 0.); + assert_release(!is_empty()); + + auto tdom = tdomain(); + SampledTraj straj; + for(double t = tdom.lb() ; t < tdom.ub() ; t+=dt) + straj.set((*this)(t), t); + straj.set((*this)(tdom.ub()), tdom.ub()); + return straj; + } + + template + template + SampledTraj TrajBase::sampled_as(const SampledTraj& x) const + { + assert_release(x.tdomain().is_subset(this->tdomain())); + + SampledTraj straj; + for(const auto& [ti,dump] : x) + straj.set((*this)(ti), ti); + return straj; + } + + template + SampledTraj TrajBase::primitive(double dt) const + { + assert_release(dt > 0.); + assert_release(!is_empty()); + + T s = [this]() { + if constexpr(std::is_same_v) + return 0.; + else + return T((*this)(this->tdomain().lb())).init(0.); + }(); + + SampledTraj p; + double t = tdomain().lb(), last_t = t; + p.set(s, t); t += dt; + + while(t < tdomain().ub()) + { + s += ((*this)(last_t)+(*this)(t))*dt/2.; + p.set(s, t); + last_t = t; + t += dt; + } + + t = tdomain().ub(); + s += ((*this)(last_t)+(*this)(t))*(t-last_t)/2.; + p.set(s, t); + + return p; + } +} From 5a83e00cf3c2485b83dd8bb6ce606c21beb12ea9 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 09:31:13 +0200 Subject: [PATCH 08/21] [traj] added codac2_TrajBase_impl.h to CMakeLists.txt --- src/core/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 81565e93c..d06db4fd8 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -284,6 +284,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/trajectory/codac2_traj_cart_prod.h ${CMAKE_CURRENT_SOURCE_DIR}/trajectory/codac2_Traj_operator.h ${CMAKE_CURRENT_SOURCE_DIR}/trajectory/codac2_TrajBase.h + ${CMAKE_CURRENT_SOURCE_DIR}/trajectory/codac2_TrajBase_impl.h ) ################################################################################ From 52af2150260a8be81be62d41a56e29287144f13d Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:11:10 +0200 Subject: [PATCH 09/21] [tube] revised binding and operators of SlicedTube --- python/src/core/CMakeLists.txt | 3 +- python/src/core/codac2_py_core.cpp | 17 +- .../domains/tube/codac2_py_SlicedTube.cpp | 615 ---------- .../core/domains/tube/codac2_py_SlicedTube.h | 328 ++++++ .../tube/codac2_py_SlicedTube_operations.cpp | 404 +++++++ src/core/domains/tube/codac2_SlicedTube.h | 16 +- .../tube/codac2_SlicedTube_operations.cpp | 6 +- .../tube/codac2_SlicedTube_operations.h | 1046 ++++++++++++----- 8 files changed, 1502 insertions(+), 933 deletions(-) delete mode 100644 python/src/core/domains/tube/codac2_py_SlicedTube.cpp create mode 100644 python/src/core/domains/tube/codac2_py_SlicedTube.h create mode 100644 python/src/core/domains/tube/codac2_py_SlicedTube_operations.cpp diff --git a/python/src/core/CMakeLists.txt b/python/src/core/CMakeLists.txt index 65fe7acf2..d569f74bd 100644 --- a/python/src/core/CMakeLists.txt +++ b/python/src/core/CMakeLists.txt @@ -55,7 +55,8 @@ domains/zonotope/codac2_py_Parallelepiped.cpp domains/zonotope/codac2_py_Zonotope.cpp domains/tube/codac2_py_Slice.h - domains/tube/codac2_py_SlicedTube.cpp + domains/tube/codac2_py_SlicedTube.h + domains/tube/codac2_py_SlicedTube_operations.cpp domains/tube/codac2_py_TDomain.cpp domains/tube/codac2_py_TimePropag.cpp domains/tube/codac2_py_TSlice.cpp diff --git a/python/src/core/codac2_py_core.cpp b/python/src/core/codac2_py_core.cpp index 05f160098..370630623 100644 --- a/python/src/core/codac2_py_core.cpp +++ b/python/src/core/codac2_py_core.cpp @@ -21,6 +21,7 @@ #include "codac2_py_CtcInverse.h" #include "codac2_py_MatrixBlock.h" #include "codac2_py_Slice.h" +#include "codac2_py_SlicedTube.h" using namespace codac2; namespace py = pybind11; @@ -79,7 +80,11 @@ void export_TimePropag(py::module& m); void export_TSlice(py::module& m); py::class_ export_TubeBase(py::module& m); void export_tube_cart_prod(py::module& m); -void export_SlicedTube(py::module& m); +void export_SlicedTube_operations( + py::module& m, + py::class_,TubeBase>& py_SlicedTube_Interval, + py::class_,TubeBase>& py_SlicedTube_IntervalVector, + py::class_,TubeBase>& py_SlicedTube_IntervalMatrix); // functions void export_VarBase(py::module& m); @@ -248,7 +253,15 @@ PYBIND11_MODULE(_core, m) export_TDomain(m); export_TSlice(m); auto tube_base = export_TubeBase(m); - export_SlicedTube(m); + auto py_SlicedTube_Interval = export_SlicedTube(m, "SlicedTube_Interval"); + auto py_SlicedTube_IntervalVector = export_SlicedTube(m, "SlicedTube_IntervalVector"); + auto py_SlicedTube_IntervalMatrix = export_SlicedTube(m, "SlicedTube_IntervalMatrix"); + export_SlicedTube_operations( + m, + py_SlicedTube_Interval, + py_SlicedTube_IntervalVector, + py_SlicedTube_IntervalMatrix + ); export_tube_cart_prod(m); export_arithmetic_add(py_V, py_IV, py_M, py_IM, py_B, py_IB); diff --git a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp b/python/src/core/domains/tube/codac2_py_SlicedTube.cpp deleted file mode 100644 index 19c9eef08..000000000 --- a/python/src/core/domains/tube/codac2_py_SlicedTube.cpp +++ /dev/null @@ -1,615 +0,0 @@ -/** - * Codac binding (core) - * ---------------------------------------------------------------------------- - * \date 2024 - * \author Simon Rohou - * \copyright Copyright 2024 Codac Team - * \license GNU Lesser General Public License (LGPL) - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "codac2_py_matlab.h" -#include "codac2_py_SlicedTubeBase_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): -#include "codac2_py_SlicedTube_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): -#include "codac2_py_SlicedTube_operations_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): - -using namespace std; -using namespace codac2; -namespace py = pybind11; -using namespace pybind11::literals; - - -template -py::class_,TubeBase> _export_SlicedTube(py::module& m, const std::string& name) -{ - py::class_,TubeBase> exported_slicedtube_class(m, name.c_str(), SLICEDTUBEBASE_MAIN); - exported_slicedtube_class - - .def(py::init&,const T&>(), - SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_T_REF, - "tdomain"_a, "codomain"_a) - - .def(py::init&,const AnalyticFunction::Type>&>(), - SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICFUNCTION_TYPENAME_EXPRTYPE_T_TYPE_REF, - "tdomain"_a, "f"_a) - - .def(py::init&,const AnalyticTraj::Type>&>(), - SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICTRAJ_TYPENAME_EXPRTYPE_T_TYPE_REF, - "tdomain"_a, "x"_a) - - .def(py::init&,const SampledTraj::Type::Scalar>&>(), - SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_SAMPLEDTRAJ_V_REF, - "tdomain"_a, "x"_a) - - .def(py::init&>(), - SLICEDTUBE_T_SLICEDTUBE_CONST_SLICEDTUBE_T_REF, - "x"_a) - - .def("__iter__", [](const SlicedTube& x) - { - return py::make_iterator(x.begin(), x.end()); - }, - py::keep_alive<0,1>()) // essential: keep object alive while iterator exists - - // From SlicedTubeBase class: - .def("nb_slices", &SlicedTube::nb_slices, - SIZET_SLICEDTUBEBASE_NB_SLICES_CONST) - - .def("size", &SlicedTube::size, - INDEX_SLICEDTUBE_T_SIZE_CONST) - - .def("volume", &SlicedTube::volume, - DOUBLE_SLICEDTUBE_T_VOLUME_CONST) - - .def("first_slice", [](SlicedTube& x) -> Slice& - { - return *x.first_slice(); - }, - py::return_value_policy::reference, - SHARED_PTR_SLICE_T_SLICEDTUBE_T_FIRST_SLICE) - - .def("last_slice", [](SlicedTube& x) -> Slice& - { - return *x.last_slice(); - }, - py::return_value_policy::reference, - SHARED_PTR_SLICE_T_SLICEDTUBE_T_LAST_SLICE) - - .def("slice", [](SlicedTube& x, std::shared_ptr it) -> Slice& - { - return *x.slice(it); - }, - py::return_value_policy::reference, - SHARED_PTR_SLICE_T_SLICEDTUBE_T_SLICE_SHARED_PTR_TSLICE, - "it"_a) - - .def("is_empty", &SlicedTube::is_empty, - BOOL_SLICEDTUBE_T_IS_EMPTY_CONST) - - .def("is_unbounded", &SlicedTube::is_unbounded, - BOOL_SLICEDTUBE_T_IS_UNBOUNDED_CONST) - - .def("codomain", &SlicedTube::codomain, - T_SLICEDTUBE_T_CODOMAIN_CONST) - - .def("__call__", [](const SlicedTube& x, const Interval& t) - { - return x(t); - }, - T_SLICEDTUBE_T_OPERATORCALL_CONST_INTERVAL_REF_CONST, - "t"_a) - - .def("enclosed_bounds", &SlicedTube::enclosed_bounds, - PAIR_TT_SLICEDTUBE_T_ENCLOSED_BOUNDS_CONST_INTERVAL_REF_CONST, - "t"_a) - - .def("set", (void (SlicedTube::*)(const T&)) &SlicedTube::set, - VOID_SLICEDTUBE_T_SET_CONST_T_REF, - "codomain"_a) - - .def("set", (void (SlicedTube::*)(const T&,double)) &SlicedTube::set, - VOID_SLICEDTUBE_T_SET_CONST_T_REF_DOUBLE, - "codomain"_a, "t"_a) - - .def("set", (void (SlicedTube::*)(const T&,const Interval&)) &SlicedTube::set, - VOID_SLICEDTUBE_T_SET_CONST_T_REF_CONST_INTERVAL_REF, - "codomain"_a, "t"_a) - - .def("set_ith_slice", &SlicedTube::set_ith_slice, - VOID_SLICEDTUBE_T_SET_ITH_SLICE_CONST_T_REF_INDEX, - "codomain"_a, "i"_a) - - .def("inflate", (const SlicedTube& (SlicedTube::*)(const double&)) &SlicedTube::inflate, - CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_V_REF, - "rad"_a) - - .def("inflate", (const SlicedTube& (SlicedTube::*)(const SampledTraj&)) &SlicedTube::inflate, - CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_SAMPLEDTRAJ_V_REF, - "rad"_a) - ; - - if constexpr(std::is_same_v) - { - exported_slicedtube_class - - .def("inflate", (const SlicedTube& (SlicedTube::*)(const Vector&)) &SlicedTube::inflate, - CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_V_REF, - "rad"_a) - - .def("inflate", (const SlicedTube& (SlicedTube::*)(const SampledTraj&)) &SlicedTube::inflate, - CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_SAMPLEDTRAJ_V_REF, - "rad"_a) - ; - } - - exported_slicedtube_class - - .def(py::self == py::self, - BOOL_SLICEDTUBE_T_OPERATOREQ_CONST_SLICEDTUBE_REF_CONST, - "x"_a) - - .def(py::self != py::self, - "x"_a) - - .def(py::self &= py::self, - SLICEDTUBE_REF_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, - "x"_a) - - // For MATLAB compatibility - .def("self_inter", &SlicedTube::operator&=, - SLICEDTUBE_REF_SLICEDTUBE_T_OPERATORINTEREQ_CONST_SLICEDTUBE_REF, - "x"_a) - - .def("as_function", &SlicedTube::as_function, - ANALYTICFUNCTION_TYPENAME_EXPRTYPE_T_TYPE_SLICEDTUBE_T_AS_FUNCTION_CONST) - - .def("all_reals_value", &SlicedTube::all_reals_value, - T_SLICEDTUBE_T_ALL_REALS_VALUE_CONST) - - .def("empty_value", &SlicedTube::empty_value, - T_SLICEDTUBE_T_EMPTY_VALUE_CONST) - - .def("__repr__", [](const SlicedTube& x) { - std::ostringstream stream; - stream << x; - return string(stream.str()); - }, - OSTREAM_REF_OPERATOROUT_OSTREAM_REF_CONST_SLICEDTUBE_T_REF) - ; - - if constexpr(std::is_same_v || std::is_same_v) - { - exported_slicedtube_class - - .def("__call__", [](const SlicedTube& x, const Interval& t, const SlicedTube& v) - { - return x(t,v); - }, - T_SLICEDTUBE_T_OPERATORCALL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST, - "t"_a, "v"_a) - - .def("integral", (T (SlicedTube::*)(const Interval&) const) &SlicedTube::integral, - T_SLICEDTUBE_T_INTEGRAL_CONST_INTERVAL_REF_CONST, - "t"_a) - - .def("integral", (T (SlicedTube::*)(const Interval&,const Interval&) const) &SlicedTube::integral, - T_SLICEDTUBE_T_INTEGRAL_CONST_INTERVAL_REF_CONST_INTERVAL_REF_CONST, - "t1"_a, "t2"_a) - - .def("partial_integral", (std::pair (SlicedTube::*)(const Interval&) const) &SlicedTube::partial_integral, - PAIR_TT_SLICEDTUBE_T_PARTIAL_INTEGRAL_CONST_INTERVAL_REF_CONST, - "t"_a) - - .def("partial_integral", (std::pair (SlicedTube::*)(const Interval&,const Interval&) const) &SlicedTube::partial_integral, - PAIR_TT_SLICEDTUBE_T_PARTIAL_INTEGRAL_CONST_INTERVAL_REF_CONST_INTERVAL_REF_CONST, - "t1"_a, "t2"_a) - - .def("primitive", (SlicedTube (SlicedTube::*)() const) &SlicedTube::primitive, - SLICEDTUBE_T_SLICEDTUBE_T_PRIMITIVE_CONST) - - .def("primitive", (SlicedTube (SlicedTube::*)(const T&) const) &SlicedTube::primitive, - SLICEDTUBE_T_SLICEDTUBE_T_PRIMITIVE_CONST_T_REF_CONST, - "x0"_a) - - .def("invert", (Interval (SlicedTube::*)(const T&) const) &SlicedTube::invert, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST, - "y"_a) - - .def("invert", (Interval (SlicedTube::*)(const T&,const Interval&) const) &SlicedTube::invert, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "t"_a) - - .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t) - { - vector vector_t; - x.invert(y, vector_t); - v_t.clear(); - for(const auto& ti : vector_t) - v_t.append(ti); - }, - VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST, - "y"_a, "v_t"_a) - - .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const Interval& t) - { - vector vector_t; - x.invert(y, vector_t, t); - v_t.clear(); - for(const auto& ti : vector_t) - v_t.append(ti); - }, - VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v_t"_a, "t"_a) - - .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&) const) &SlicedTube::invert, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST, - "y"_a, "v"_a) - - .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&,const Interval&) const) &SlicedTube::invert, - INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v"_a, "t"_a) - - .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v) - { - vector vector_t; - x.invert(y, vector_t, v); - v_t.clear(); - for(const auto& ti : vector_t) - v_t.append(ti); - }, - VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST, - "y"_a, "v_t"_a, "v"_a) - - .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v, const Interval& t) - { - vector vector_t; - x.invert(y, vector_t, v, t); - v_t.clear(); - for(const auto& ti : vector_t) - v_t.append(ti); - }, - VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, - "y"_a, "v_t"_a, "v"_a, "t"_a) - - .def("mid", &SlicedTube::mid, - SAMPLEDTRAJ_TYPENAME_SCALAR_T_TYPE_SLICEDTUBE_T_MID_CONST); - ; - } - - if constexpr(std::is_same_v) - { - exported_slicedtube_class - - .def( - #if FOR_MATLAB - "get_item" - #else - "__getitem__" - #endif - , - [](const SlicedTube& x, Index_type i) -> SlicedTube - { - matlab::test_integer(i); - return x[matlab::input_index(i)]; - }, - SLICEDTUBE_INTERVAL_SLICEDTUBE_T_OPERATORCOMPO_INDEX_CONST, - "i"_a) - - .def("get_item_0", - [](const SlicedTube& x, Index_type i) -> SlicedTube - { - matlab::test_integer(i); - return x[i]; - }, - SLICEDTUBE_INTERVAL_SLICEDTUBE_T_OPERATORCOMPO_INDEX_CONST, - "i"_a) - - .def("subvector", - [](const SlicedTube& x, Index_type i, Index_type j) -> SlicedTube - { - matlab::test_integer(i,j); - return x.subvector(matlab::input_index(i),matlab::input_index(j)); - }, - SLICEDTUBE_INTERVALVECTOR_SLICEDTUBE_T_SUBVECTOR_INDEX_INDEX_CONST, - "i"_a, "j"_a) - - .def("subvector_0", - [](const SlicedTube& x, Index_type i, Index_type j) -> SlicedTube - { - matlab::test_integer(i,j); - return x.subvector(i,j); - }, - SLICEDTUBE_INTERVALVECTOR_SLICEDTUBE_T_SUBVECTOR_INDEX_INDEX_CONST, - "i"_a, "j"_a) - ; - } - - return exported_slicedtube_class; -} - -template -void add_tube_operators(py::class_,TubeBase>& pyclass) -{ - if constexpr(!FOR_MATLAB) - { - pyclass - - .def(py::self & py::self, - SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self &= py::self, - SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self | py::self, - SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self |= py::self, - SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - ; - } - - if constexpr(FOR_MATLAB) - { - // For MATLAB compatibility - pyclass - - .def("inter", &SlicedTube::operator&, - SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("self_inter", &SlicedTube::operator&=, - SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("union", &SlicedTube::operator|, - SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("self_union", &SlicedTube::operator|=, - SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - ; - } - - pyclass - - .def("__add__", (const SlicedTube&(*)(const SlicedTube&)) &codac2::operator+, - CONST_SLICEDTUBE_T_REF_OPERATORPLUS_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__add__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator+, - SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__add__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator+, - SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, - py::is_operator()) - - .def("__radd__", (SlicedTube(*)(const T&,const SlicedTube&)) &codac2::operator+, - SLICEDTUBE_T_OPERATORPLUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__sub__", (SlicedTube(*)(const SlicedTube&)) &codac2::operator-, - SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__sub__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator-, - SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__sub__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator-, - SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, - py::is_operator()) - - .def("__rsub__", (SlicedTube(*)(const T&,const SlicedTube&)) &codac2::operator-, - SLICEDTUBE_T_OPERATORMINUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF, - py::is_operator()) - - .def("__rmul__", (SlicedTube(*)(const Interval&,const SlicedTube&)) &codac2::operator*, - SLICEDTUBE_T_OPERATORMUL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__mul__", (SlicedTube(*)(const Interval&,const SlicedTube&)) &codac2::operator*, - SLICEDTUBE_T_OPERATORMUL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def("__truediv__", (SlicedTube(*)(const SlicedTube&,const Interval&)) &codac2::operator/, - SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, - py::is_operator()) - ; -} - - -void export_SlicedTube(py::module& m) -{ - auto py_SlicedTube_Interval = _export_SlicedTube(m, "SlicedTube_Interval"); - auto py_SlicedTube_IntervalVector = _export_SlicedTube(m, "SlicedTube_IntervalVector"); - auto py_SlicedTube_IntervalMatrix = _export_SlicedTube(m, "SlicedTube_IntervalMatrix"); - - add_tube_operators(py_SlicedTube_Interval); - - py_SlicedTube_Interval - - .def(py::self | py::self, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self & py::self, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self * py::self, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(py::self / py::self, - SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - .def(double() / py::self, - SLICEDTUBE_T_OPERATORDIV_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - ; - - add_tube_operators(py_SlicedTube_IntervalMatrix); - add_tube_operators(py_SlicedTube_IntervalVector); - py_SlicedTube_IntervalMatrix - - .def("__mul__", [](const SlicedTube& x1, const SlicedTube& x2) { return x1*x2; }, - SLICEDTUBE_INTERVALVECTOR_OPERATORMUL_CONST_SLICEDTUBE_INTERVALMATRIX_REF_CONST_SLICEDTUBE_INTERVALVECTOR_REF, - py::is_operator()) - - .def("__mul__", [](const SlicedTube& x1, const SlicedTube& x2) { return x1*x2; }, - SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, - py::is_operator()) - - ; - - m - - .def("sqr", (SlicedTube (*)(const SlicedTube&)) &codac2::sqr, - SLICEDTUBE_INTERVAL_SQR_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sqrt", (SlicedTube (*)(const SlicedTube&)) &codac2::sqrt, - SLICEDTUBE_INTERVAL_SQRT_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("pow", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::pow, - SLICEDTUBE_INTERVAL_POW_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - //.def("root", (SlicedTube (*)(const SlicedTube&,int)) &codac2::root, - // SAMPLEDTRAJ_DOUBLE_ROOT_CONST_SAMPLEDTRAJ_DOUBLE_REF_INT, - // "x1"_a, "x2"_a, py::is_operator()) - - .def("exp", (SlicedTube (*)(const SlicedTube&)) &codac2::exp, - SLICEDTUBE_INTERVAL_EXP_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("log", (SlicedTube (*)(const SlicedTube&)) &codac2::log, - SLICEDTUBE_INTERVAL_LOG_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("cos", (SlicedTube (*)(const SlicedTube&)) &codac2::cos, - SLICEDTUBE_INTERVAL_COS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sin", (SlicedTube (*)(const SlicedTube&)) &codac2::sin, - SLICEDTUBE_INTERVAL_SIN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("tan", (SlicedTube (*)(const SlicedTube&)) &codac2::tan, - SLICEDTUBE_INTERVAL_TAN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("acos", (SlicedTube (*)(const SlicedTube&)) &codac2::acos, - SLICEDTUBE_INTERVAL_ACOS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("asin", (SlicedTube (*)(const SlicedTube&)) &codac2::asin, - SLICEDTUBE_INTERVAL_ASIN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atan", (SlicedTube (*)(const SlicedTube&)) &codac2::atan, - SLICEDTUBE_INTERVAL_ATAN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atan2", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::atan2, - SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("atan2", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::atan2, - SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("atan2", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::atan2, - SLICEDTUBE_INTERVAL_ATAN2_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("cosh", (SlicedTube (*)(const SlicedTube&)) &codac2::cosh, - SLICEDTUBE_INTERVAL_COSH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("sinh", (SlicedTube (*)(const SlicedTube&)) &codac2::sinh, - SLICEDTUBE_INTERVAL_SINH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("tanh", (SlicedTube (*)(const SlicedTube&)) &codac2::tanh, - SLICEDTUBE_INTERVAL_TANH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("acosh", (SlicedTube (*)(const SlicedTube&)) &codac2::acosh, - SLICEDTUBE_INTERVAL_ACOSH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("asinh", (SlicedTube (*)(const SlicedTube&)) &codac2::asinh, - SLICEDTUBE_INTERVAL_ASINH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("atanh", (SlicedTube (*)(const SlicedTube&)) &codac2::atanh, - SLICEDTUBE_INTERVAL_ATANH_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("abs", (SlicedTube (*)(const SlicedTube&)) &codac2::abs, - SLICEDTUBE_INTERVAL_ABS_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("min", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::min, - SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("min", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::min, - SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("min", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::min, - SLICEDTUBE_INTERVAL_MIN_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::max, - SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::max, - SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("max", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::max, - SLICEDTUBE_INTERVAL_MAX_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, "x2"_a, py::is_operator()) - - .def("sign", (SlicedTube (*)(const SlicedTube&)) &codac2::sign, - SLICEDTUBE_INTERVAL_SIGN_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("integer", (SlicedTube (*)(const SlicedTube&)) &codac2::integer, - SLICEDTUBE_INTERVAL_INTEGER_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("floor", (SlicedTube (*)(const SlicedTube&)) &codac2::floor, - SLICEDTUBE_INTERVAL_FLOOR_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - .def("ceil", (SlicedTube (*)(const SlicedTube&)) &codac2::ceil, - SLICEDTUBE_INTERVAL_CEIL_CONST_SLICEDTUBE_INTERVAL_REF, - "x1"_a, py::is_operator()) - - ; -} \ No newline at end of file diff --git a/python/src/core/domains/tube/codac2_py_SlicedTube.h b/python/src/core/domains/tube/codac2_py_SlicedTube.h new file mode 100644 index 000000000..85bfc96e4 --- /dev/null +++ b/python/src/core/domains/tube/codac2_py_SlicedTube.h @@ -0,0 +1,328 @@ +/** + * Codac binding (core) + * ---------------------------------------------------------------------------- + * \date 2024 + * \author Simon Rohou + * \copyright Copyright 2024 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "codac2_py_matlab.h" +#include "codac2_py_SlicedTubeBase_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): +#include "codac2_py_SlicedTube_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): +#include "codac2_py_SlicedTube_operations_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py): + +using namespace std; +using namespace codac2; +namespace py = pybind11; +using namespace pybind11::literals; + +template +py::class_,TubeBase> export_SlicedTube(py::module& m, const std::string& name) +{ + py::class_,TubeBase> exported_slicedtube_class(m, name.c_str(), SLICEDTUBEBASE_MAIN); + exported_slicedtube_class + + .def(py::init&,const T&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_T_REF, + "tdomain"_a, "codomain"_a) + + .def(py::init&,const AnalyticFunction::Type>&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICFUNCTION_TYPENAME_EXPRTYPE_T_TYPE_REF, + "tdomain"_a, "f"_a) + + .def(py::init&,const AnalyticTraj::Type>&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_ANALYTICTRAJ_V_REF, + "tdomain"_a, "x"_a) + + .def(py::init&,const SampledTraj::Type::Scalar>&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SHARED_PTR_TDOMAIN_REF_CONST_SAMPLEDTRAJ_V_REF, + "tdomain"_a, "x"_a) + + .def(py::init&>(), + SLICEDTUBE_T_SLICEDTUBE_CONST_SLICEDTUBE_T_REF, + "x"_a) + + .def("__iter__", [](const SlicedTube& x) + { + return py::make_iterator(x.begin(), x.end()); + }, + py::keep_alive<0,1>()) // essential: keep object alive while iterator exists + + // From SlicedTubeBase class: + .def("nb_slices", &SlicedTube::nb_slices, + SIZET_SLICEDTUBEBASE_NB_SLICES_CONST) + + .def("size", &SlicedTube::size, + INDEX_SLICEDTUBE_T_SIZE_CONST) + + .def("volume", &SlicedTube::volume, + DOUBLE_SLICEDTUBE_T_VOLUME_CONST) + + .def("first_slice", [](SlicedTube& x) -> Slice& + { + return *x.first_slice(); + }, + py::return_value_policy::reference, + SHARED_PTR_SLICE_T_SLICEDTUBE_T_FIRST_SLICE) + + .def("last_slice", [](SlicedTube& x) -> Slice& + { + return *x.last_slice(); + }, + py::return_value_policy::reference, + SHARED_PTR_SLICE_T_SLICEDTUBE_T_LAST_SLICE) + + .def("slice", [](SlicedTube& x, std::shared_ptr it) -> Slice& + { + return *x.slice(it); + }, + py::return_value_policy::reference, + SHARED_PTR_SLICE_T_SLICEDTUBE_T_SLICE_SHARED_PTR_TSLICE, + "it"_a) + + .def("is_empty", &SlicedTube::is_empty, + BOOL_SLICEDTUBE_T_IS_EMPTY_CONST) + + .def("is_unbounded", &SlicedTube::is_unbounded, + BOOL_SLICEDTUBE_T_IS_UNBOUNDED_CONST) + + .def("codomain", &SlicedTube::codomain, + T_SLICEDTUBE_T_CODOMAIN_CONST) + + .def("__call__", [](const SlicedTube& x, const Interval& t) + { + return x(t); + }, + T_SLICEDTUBE_T_OPERATORCALL_CONST_INTERVAL_REF_CONST, + "t"_a) + + .def("enclosed_bounds", &SlicedTube::enclosed_bounds, + PAIR_TT_SLICEDTUBE_T_ENCLOSED_BOUNDS_CONST_INTERVAL_REF_CONST, + "t"_a) + + .def("set", (void (SlicedTube::*)(const T&)) &SlicedTube::set, + VOID_SLICEDTUBE_T_SET_CONST_T_REF, + "codomain"_a) + + .def("set", (void (SlicedTube::*)(const T&,double)) &SlicedTube::set, + VOID_SLICEDTUBE_T_SET_CONST_T_REF_DOUBLE, + "codomain"_a, "t"_a) + + .def("set", (void (SlicedTube::*)(const T&,const Interval&)) &SlicedTube::set, + VOID_SLICEDTUBE_T_SET_CONST_T_REF_CONST_INTERVAL_REF, + "codomain"_a, "t"_a) + + .def("set_ith_slice", &SlicedTube::set_ith_slice, + VOID_SLICEDTUBE_T_SET_ITH_SLICE_CONST_T_REF_INDEX, + "codomain"_a, "i"_a) + + .def("inflate", (const SlicedTube& (SlicedTube::*)(const double&)) &SlicedTube::inflate, + CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_V_REF, + "rad"_a) + + .def("inflate", (const SlicedTube& (SlicedTube::*)(const SampledTraj&)) &SlicedTube::inflate, + CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_SAMPLEDTRAJ_V_REF, + "rad"_a) + ; + + if constexpr(std::is_same_v) + { + exported_slicedtube_class + + .def("inflate", (const SlicedTube& (SlicedTube::*)(const Vector&)) &SlicedTube::inflate, + CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_V_REF, + "rad"_a) + + .def("inflate", (const SlicedTube& (SlicedTube::*)(const SampledTraj&)) &SlicedTube::inflate, + CONST_SLICEDTUBE_T_REF_SLICEDTUBE_T_INFLATE_CONST_SAMPLEDTRAJ_V_REF, + "rad"_a) + ; + } + + exported_slicedtube_class + + .def(py::self == py::self, + BOOL_SLICEDTUBE_T_OPERATOREQ_CONST_SLICEDTUBE_REF_CONST, + "x"_a) + + .def(py::self != py::self, + "x"_a) + + .def("as_function", &SlicedTube::as_function, + ANALYTICFUNCTION_TYPENAME_EXPRTYPE_T_TYPE_SLICEDTUBE_T_AS_FUNCTION_CONST) + + .def("all_reals_value", &SlicedTube::all_reals_value, + T_SLICEDTUBE_T_ALL_REALS_VALUE_CONST) + + .def("empty_value", &SlicedTube::empty_value, + T_SLICEDTUBE_T_EMPTY_VALUE_CONST) + + .def("__repr__", [](const SlicedTube& x) { + std::ostringstream stream; + stream << x; + return string(stream.str()); + }, + OSTREAM_REF_OPERATOROUT_OSTREAM_REF_CONST_SLICEDTUBE_T_REF) + ; + + if constexpr(std::is_same_v || std::is_same_v) + { + exported_slicedtube_class + + .def("__call__", [](const SlicedTube& x, const Interval& t, const SlicedTube& v) + { + return x(t,v); + }, + T_SLICEDTUBE_T_OPERATORCALL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST, + "t"_a, "v"_a) + + .def("integral", (T (SlicedTube::*)(const Interval&) const) &SlicedTube::integral, + T_SLICEDTUBE_T_INTEGRAL_CONST_INTERVAL_REF_CONST, + "t"_a) + + .def("integral", (T (SlicedTube::*)(const Interval&,const Interval&) const) &SlicedTube::integral, + T_SLICEDTUBE_T_INTEGRAL_CONST_INTERVAL_REF_CONST_INTERVAL_REF_CONST, + "t1"_a, "t2"_a) + + .def("partial_integral", (std::pair (SlicedTube::*)(const Interval&) const) &SlicedTube::partial_integral, + PAIR_TT_SLICEDTUBE_T_PARTIAL_INTEGRAL_CONST_INTERVAL_REF_CONST, + "t"_a) + + .def("partial_integral", (std::pair (SlicedTube::*)(const Interval&,const Interval&) const) &SlicedTube::partial_integral, + PAIR_TT_SLICEDTUBE_T_PARTIAL_INTEGRAL_CONST_INTERVAL_REF_CONST_INTERVAL_REF_CONST, + "t1"_a, "t2"_a) + + .def("primitive", (SlicedTube (SlicedTube::*)() const) &SlicedTube::primitive, + SLICEDTUBE_T_SLICEDTUBE_T_PRIMITIVE_CONST) + + .def("primitive", (SlicedTube (SlicedTube::*)(const T&) const) &SlicedTube::primitive, + SLICEDTUBE_T_SLICEDTUBE_T_PRIMITIVE_CONST_T_REF_CONST, + "x0"_a) + + .def("invert", (Interval (SlicedTube::*)(const T&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST, + "y"_a) + + .def("invert", (Interval (SlicedTube::*)(const T&,const Interval&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_INTERVAL_REF_CONST, + "y"_a, "t"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t) + { + vector vector_t; + x.invert(y, vector_t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST, + "y"_a, "v_t"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const Interval& t) + { + vector vector_t; + x.invert(y, vector_t, t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_INTERVAL_REF_CONST, + "y"_a, "v_t"_a, "t"_a) + + .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST, + "y"_a, "v"_a) + + .def("invert", (Interval (SlicedTube::*)(const T&,const SlicedTube&,const Interval&) const) &SlicedTube::invert, + INTERVAL_SLICEDTUBE_T_INVERT_CONST_T_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, + "y"_a, "v"_a, "t"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v) + { + vector vector_t; + x.invert(y, vector_t, v); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST, + "y"_a, "v_t"_a, "v"_a) + + .def("invert", [](const SlicedTube& x, const T& y, py::list& v_t, const SlicedTube& v, const Interval& t) + { + vector vector_t; + x.invert(y, vector_t, v, t); + v_t.clear(); + for(const auto& ti : vector_t) + v_t.append(ti); + }, + VOID_SLICEDTUBE_T_INVERT_CONST_T_REF_VECTOR_INTERVAL_REF_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF_CONST, + "y"_a, "v_t"_a, "v"_a, "t"_a) + + .def("mid", &SlicedTube::mid, + SAMPLEDTRAJ_TYPENAME_SCALAR_T_TYPE_SLICEDTUBE_T_MID_CONST); + ; + } + + if constexpr(std::is_same_v) + { + exported_slicedtube_class + + .def( + #if FOR_MATLAB + "get_item" + #else + "__getitem__" + #endif + , + [](const SlicedTube& x, Index_type i) -> SlicedTube + { + matlab::test_integer(i); + return x[matlab::input_index(i)]; + }, + SLICEDTUBE_INTERVAL_SLICEDTUBE_T_OPERATORCOMPO_INDEX_CONST, + "i"_a) + + .def("get_item_0", + [](const SlicedTube& x, Index_type i) -> SlicedTube + { + matlab::test_integer(i); + return x[i]; + }, + SLICEDTUBE_INTERVAL_SLICEDTUBE_T_OPERATORCOMPO_INDEX_CONST, + "i"_a) + + .def("subvector", + [](const SlicedTube& x, Index_type i, Index_type j) -> SlicedTube + { + matlab::test_integer(i,j); + return x.subvector(matlab::input_index(i),matlab::input_index(j)); + }, + SLICEDTUBE_INTERVALVECTOR_SLICEDTUBE_T_SUBVECTOR_INDEX_INDEX_CONST, + "i"_a, "j"_a) + + .def("subvector_0", + [](const SlicedTube& x, Index_type i, Index_type j) -> SlicedTube + { + matlab::test_integer(i,j); + return x.subvector(i,j); + }, + SLICEDTUBE_INTERVALVECTOR_SLICEDTUBE_T_SUBVECTOR_INDEX_INDEX_CONST, + "i"_a, "j"_a) + ; + } + + return exported_slicedtube_class; +} \ No newline at end of file diff --git a/python/src/core/domains/tube/codac2_py_SlicedTube_operations.cpp b/python/src/core/domains/tube/codac2_py_SlicedTube_operations.cpp new file mode 100644 index 000000000..b760e42da --- /dev/null +++ b/python/src/core/domains/tube/codac2_py_SlicedTube_operations.cpp @@ -0,0 +1,404 @@ +/** + * Codac binding (core) + * ---------------------------------------------------------------------------- + * \date 2026 + * \author Simon Rohou + * \copyright Copyright 2026 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#include +#include +#include +#include +#include +#include +#include "codac2_py_matlab.h" +#include "codac2_py_SlicedTube_operations_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py) + +using namespace codac2; +namespace py = pybind11; +using namespace pybind11::literals; + +namespace +{ + template + void bind_set_ops(py::class_,TubeBase>& pyclass) + { + if constexpr(!FOR_MATLAB) + { + pyclass + .def(py::self & py::self, + SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def(py::self &= py::self, + SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def(py::self | py::self, + SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def(py::self |= py::self, + SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()); + } + else + { + pyclass + .def("inter", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator&, + SLICEDTUBE_T_OPERATORINTER_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def("self_inter", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator&=, + SLICEDTUBE_T_REF_OPERATORINTEREQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + .def("union", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator|, + SLICEDTUBE_T_OPERATORUNION_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + .def("self_union", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator|=, + SLICEDTUBE_T_REF_OPERATORUNIONEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + } + + template + void bind_add_sub_ops(py::class_,TubeBase>& pyclass) + { + pyclass + .def("__pos__", + (const SlicedTube&(*)(const SlicedTube&)) &codac2::operator+, + CONST_SLICEDTUBE_T_REF_OPERATORPLUS_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__add__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator+, + SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__add__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator+, + SLICEDTUBE_T_OPERATORPLUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, + py::is_operator()) + + .def("__radd__", + [](const SlicedTube& x2, const T& x1) { return x1 + x2; }, + SLICEDTUBE_T_OPERATORPLUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__iadd__", (SlicedTube&(*)(SlicedTube&,const T&)) &codac2::operator+=, + SLICEDTUBE_T_REF_OPERATORPLUSEQ_SLICEDTUBE_T_REF_CONST_Q_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__iadd__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator+=, + SLICEDTUBE_T_REF_OPERATORPLUSEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__neg__", (SlicedTube(*)(const SlicedTube&)) &codac2::operator-, + SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__sub__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator-, + SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__sub__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator-, + SLICEDTUBE_T_OPERATORMINUS_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, + py::is_operator()) + + .def("__rsub__", + [](const SlicedTube& x2, const T& x1) { return x1 - x2; }, + SLICEDTUBE_T_OPERATORMINUS_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__isub__", (SlicedTube&(*)(SlicedTube&,const T&)) &codac2::operator-=, + SLICEDTUBE_T_REF_OPERATORMINUSEQ_SLICEDTUBE_T_REF_CONST_Q_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__isub__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator-=, + SLICEDTUBE_T_REF_OPERATORMINUSEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + + template + void bind_mul_ops(py::class_,TubeBase>& pyclass) + { + pyclass + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const Interval&)) &codac2::operator*, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF, + py::is_operator()) + + .def("__rmul__", + [](const SlicedTube& x2, const T& x1) { return x1 * x2; }, + SLICEDTUBE_T_OPERATORMUL_CONST_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__imul__", (SlicedTube&(*)(SlicedTube&,const Interval&)) &codac2::operator*=, + SLICEDTUBE_T_REF_OPERATORMULEQ_SLICEDTUBE_T_REF_CONST_Q_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + + if constexpr(std::is_same_v) + { + pyclass + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, + SLICEDTUBE_INTERVAL_OPERATORMUL_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::is_operator()) + + .def("__imul__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator*=, + SLICEDTUBE_T_REF_OPERATORMULEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + else + { + pyclass + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, + std::is_same_v + ? SLICEDTUBE_INTERVALVECTOR_OPERATORMUL_CONST_SLICEDTUBE_INTERVALVECTOR_REF_CONST_SLICEDTUBE_INTERVALVECTOR_REF + : SLICEDTUBE_INTERVALMATRIX_OPERATORMUL_CONST_SLICEDTUBE_INTERVALMATRIX_REF_CONST_SLICEDTUBE_INTERVALMATRIX_REF, + py::is_operator()) + + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::is_operator()) + + .def("__rmul__", + [](const SlicedTube& x2, const SlicedTube& x1) { return x1 * x2; }, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const T&)) &codac2::operator*, + SLICEDTUBE_T_OPERATORMUL_CONST_SLICEDTUBE_T_REF_CONST_Q_REF, + py::is_operator()) + + .def("__rmul__", + [](const SlicedTube& x2, const T& x1) { return x1 * x2; }, + SLICEDTUBE_T_OPERATORMUL_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__imul__", (SlicedTube&(*)(SlicedTube&,const T&)) &codac2::operator*=, + SLICEDTUBE_T_REF_OPERATORMULEQ_SLICEDTUBE_T_REF_CONST_Q_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__imul__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator*=, + SLICEDTUBE_T_REF_OPERATORMULEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()) + + .def("__imul__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator*=, + SLICEDTUBE_T_REF_OPERATORMULEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + } + + template + void bind_div_ops(py::class_,TubeBase>& pyclass) + { + pyclass + .def("__truediv__", (SlicedTube(*)(const SlicedTube&,const Interval&)) &codac2::operator/, + SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_INTERVAL_REF, + py::is_operator()) + + .def("__itruediv__", (SlicedTube&(*)(SlicedTube&,const Interval&)) &codac2::operator/=, + SLICEDTUBE_T_REF_OPERATORDIVEQ_SLICEDTUBE_T_REF_CONST_Q_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + + if constexpr(std::is_same_v) + { + pyclass + .def("__truediv__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator/, + SLICEDTUBE_INTERVAL_OPERATORDIV_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::is_operator()) + + .def("__rtruediv__", + [](const SlicedTube& x2, const Interval& x1) { return x1 / x2; }, + SLICEDTUBE_T_OPERATORDIV_CONST_Q_REF_CONST_SLICEDTUBE_T_REF, + py::is_operator()) + + .def("__itruediv__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator/=, + SLICEDTUBE_T_REF_OPERATORDIVEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_T_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + else + { + pyclass + .def("__truediv__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator/, + SLICEDTUBE_T_OPERATORDIV_CONST_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::is_operator()) + + .def("__itruediv__", (SlicedTube&(*)(SlicedTube&,const SlicedTube&)) &codac2::operator/=, + SLICEDTUBE_T_REF_OPERATORDIVEQ_SLICEDTUBE_T_REF_CONST_SLICEDTUBE_INTERVAL_REF, + py::return_value_policy::reference_internal, + py::is_operator()); + } + } + + void bind_scalar_slicedtube_functions(py::module& m) + { + m + .def("sqr", (SlicedTube (*)(const SlicedTube&)) &codac2::sqr, + SLICEDTUBE_INTERVAL_SQR_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("sqrt", (SlicedTube (*)(const SlicedTube&)) &codac2::sqrt, + SLICEDTUBE_INTERVAL_SQRT_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("pow", (SlicedTube (*)(const SlicedTube&,int)) &codac2::pow, + SLICEDTUBE_INTERVAL_POW_CONST_SLICEDTUBE_INTERVAL_REF_INT, + "x1"_a, "x2"_a, py::is_operator()) + + .def("pow", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::pow, + SLICEDTUBE_INTERVAL_POW_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("exp", (SlicedTube (*)(const SlicedTube&)) &codac2::exp, + SLICEDTUBE_INTERVAL_EXP_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("log", (SlicedTube (*)(const SlicedTube&)) &codac2::log, + SLICEDTUBE_INTERVAL_LOG_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("cos", (SlicedTube (*)(const SlicedTube&)) &codac2::cos, + SLICEDTUBE_INTERVAL_COS_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("sin", (SlicedTube (*)(const SlicedTube&)) &codac2::sin, + SLICEDTUBE_INTERVAL_SIN_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("tan", (SlicedTube (*)(const SlicedTube&)) &codac2::tan, + SLICEDTUBE_INTERVAL_TAN_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("acos", (SlicedTube (*)(const SlicedTube&)) &codac2::acos, + SLICEDTUBE_INTERVAL_ACOS_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("asin", (SlicedTube (*)(const SlicedTube&)) &codac2::asin, + SLICEDTUBE_INTERVAL_ASIN_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("atan", (SlicedTube (*)(const SlicedTube&)) &codac2::atan, + SLICEDTUBE_INTERVAL_ATAN_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("atan2", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::atan2, + SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("atan2", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::atan2, + SLICEDTUBE_INTERVAL_ATAN2_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("atan2", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::atan2, + SLICEDTUBE_INTERVAL_ATAN2_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("cosh", (SlicedTube (*)(const SlicedTube&)) &codac2::cosh, + SLICEDTUBE_INTERVAL_COSH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("sinh", (SlicedTube (*)(const SlicedTube&)) &codac2::sinh, + SLICEDTUBE_INTERVAL_SINH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("tanh", (SlicedTube (*)(const SlicedTube&)) &codac2::tanh, + SLICEDTUBE_INTERVAL_TANH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("acosh", (SlicedTube (*)(const SlicedTube&)) &codac2::acosh, + SLICEDTUBE_INTERVAL_ACOSH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("asinh", (SlicedTube (*)(const SlicedTube&)) &codac2::asinh, + SLICEDTUBE_INTERVAL_ASINH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("atanh", (SlicedTube (*)(const SlicedTube&)) &codac2::atanh, + SLICEDTUBE_INTERVAL_ATANH_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("abs", (SlicedTube (*)(const SlicedTube&)) &codac2::abs, + SLICEDTUBE_INTERVAL_ABS_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("min", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::min, + SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("min", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::min, + SLICEDTUBE_INTERVAL_MIN_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("min", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::min, + SLICEDTUBE_INTERVAL_MIN_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("max", (SlicedTube (*)(const SlicedTube&,const SlicedTube&)) &codac2::max, + SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("max", (SlicedTube (*)(const SlicedTube&,const Interval&)) &codac2::max, + SLICEDTUBE_INTERVAL_MAX_CONST_SLICEDTUBE_INTERVAL_REF_CONST_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("max", (SlicedTube (*)(const Interval&,const SlicedTube&)) &codac2::max, + SLICEDTUBE_INTERVAL_MAX_CONST_INTERVAL_REF_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, "x2"_a, py::is_operator()) + + .def("sign", (SlicedTube (*)(const SlicedTube&)) &codac2::sign, + SLICEDTUBE_INTERVAL_SIGN_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("integer", (SlicedTube (*)(const SlicedTube&)) &codac2::integer, + SLICEDTUBE_INTERVAL_INTEGER_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("floor", (SlicedTube (*)(const SlicedTube&)) &codac2::floor, + SLICEDTUBE_INTERVAL_FLOOR_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()) + + .def("ceil", (SlicedTube (*)(const SlicedTube&)) &codac2::ceil, + SLICEDTUBE_INTERVAL_CEIL_CONST_SLICEDTUBE_INTERVAL_REF, + "x1"_a, py::is_operator()); + } +} + +void export_SlicedTube_operations( + py::module& m, + py::class_,TubeBase>& py_SlicedTube_Interval, + py::class_,TubeBase>& py_SlicedTube_IntervalVector, + py::class_,TubeBase>& py_SlicedTube_IntervalMatrix) +{ + bind_set_ops(py_SlicedTube_Interval); + bind_set_ops(py_SlicedTube_IntervalVector); + bind_set_ops(py_SlicedTube_IntervalMatrix); + + bind_add_sub_ops(py_SlicedTube_Interval); + bind_add_sub_ops(py_SlicedTube_IntervalVector); + bind_add_sub_ops(py_SlicedTube_IntervalMatrix); + + bind_mul_ops(py_SlicedTube_Interval); + bind_mul_ops(py_SlicedTube_IntervalVector); + bind_mul_ops(py_SlicedTube_IntervalMatrix); + + bind_div_ops(py_SlicedTube_Interval); + bind_div_ops(py_SlicedTube_IntervalVector); + bind_div_ops(py_SlicedTube_IntervalMatrix); + + py_SlicedTube_IntervalMatrix + .def("__mul__", (SlicedTube(*)(const SlicedTube&,const SlicedTube&)) &codac2::operator*, + SLICEDTUBE_INTERVALVECTOR_OPERATORMUL_CONST_SLICEDTUBE_INTERVALMATRIX_REF_CONST_SLICEDTUBE_INTERVALVECTOR_REF, + py::is_operator()); + + bind_scalar_slicedtube_functions(m); +} diff --git a/src/core/domains/tube/codac2_SlicedTube.h b/src/core/domains/tube/codac2_SlicedTube.h index 881158e2f..d5835ff41 100644 --- a/src/core/domains/tube/codac2_SlicedTube.h +++ b/src/core/domains/tube/codac2_SlicedTube.h @@ -87,8 +87,10 @@ namespace codac2 * \param tdomain shared temporal domain of the tube * \param x analytic trajectory */ + template + requires std::is_same_v::Type,V> explicit SlicedTube(const std::shared_ptr& tdomain, - const AnalyticTraj::Type>& x) + const AnalyticTraj& x) : SlicedTubeBase(tdomain) { for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it) @@ -755,7 +757,7 @@ namespace codac2 } /** - * \brief Returns the interval inversion \f$[x]^{-1}([y])\f$. + * \brief Returns the interval inversion \f$\left[[x]^{-1}([y])\right]\f$. * * If the inversion results in several pre-images, their union is returned. * @@ -769,7 +771,7 @@ namespace codac2 /** * \ingroup codac2_slicedtube_inversion - * \brief Returns the interval inversion \f$[x]^{-1}([y])\f$. + * \brief Returns the interval inversion \f$\left[[x]^{-1}([y])\right]\f$. * * If the inversion results in several pre-images, their union is returned. * @@ -815,7 +817,7 @@ namespace codac2 } /** - * \brief Returns the optimal interval inversion \f$[x]^{-1}([y])\f$. + * \brief Returns the optimal interval inversion \f$\left[[x]^{-1}([y])\right]\f$. * * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows a finer inversion. * If the inversion results in several pre-images, their union is returned. @@ -832,7 +834,7 @@ namespace codac2 /** * \ingroup codac2_slicedtube_inversion - * \brief Returns the optimal interval inversion \f$[x]^{-1}([y])\f$. + * \brief Returns the optimal interval inversion \f$\left[[x]^{-1}([y])\right]\f$. * * The knowledge of the derivative tube \f$[v](\cdot)\f$ allows a finer inversion. * If the inversion results in several pre-images, their union is returned. @@ -1238,6 +1240,10 @@ namespace codac2 template SlicedTube(const std::shared_ptr& tdomain, const SampledTraj& f) -> SlicedTube::Domain>; + + template + SlicedTube(const std::shared_ptr& tdomain, const AnalyticTraj& f) -> + SlicedTube::Domain>; // Ctc diff --git a/src/core/domains/tube/codac2_SlicedTube_operations.cpp b/src/core/domains/tube/codac2_SlicedTube_operations.cpp index 309e86762..d9b8fcfe2 100644 --- a/src/core/domains/tube/codac2_SlicedTube_operations.cpp +++ b/src/core/domains/tube/codac2_SlicedTube_operations.cpp @@ -53,7 +53,7 @@ namespace codac2 macro_unary_tube(atan) SlicedTube atan2(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(atan2) + macro_binary_tube_tube(atan2,x1) SlicedTube atan2(const SlicedTube& x1, const Interval& x2) macro_binary_tube_real(atan2) @@ -83,7 +83,7 @@ namespace codac2 macro_unary_tube(abs) SlicedTube min(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(min) + macro_binary_tube_tube(min,x1) SlicedTube min(const SlicedTube& x1, const Interval& x2) macro_binary_tube_real(min) @@ -92,7 +92,7 @@ namespace codac2 macro_binary_real_tube(min) SlicedTube max(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(max) + macro_binary_tube_tube(max,x1) SlicedTube max(const SlicedTube& x1, const Interval& x2) macro_binary_tube_real(max) diff --git a/src/core/domains/tube/codac2_SlicedTube_operations.h b/src/core/domains/tube/codac2_SlicedTube_operations.h index 1ad9c04c6..f9e46d761 100644 --- a/src/core/domains/tube/codac2_SlicedTube_operations.h +++ b/src/core/domains/tube/codac2_SlicedTube_operations.h @@ -9,6 +9,8 @@ #pragma once +#include + #include "codac2_SlicedTube.h" #include "codac2_math.h" @@ -23,16 +25,16 @@ namespace codac2 sy->codomain() = f(sy->codomain()); \ } \ return y; \ - }; \ + } \ - #define macro_binary_tube_tube(f) \ + #define macro_binary_tube_tube(f,output_type) \ { \ assert_release(x1.tdomain() == x2.tdomain()); \ - auto y = x2; \ + auto y = output_type; \ for(auto it = y.tdomain()->begin() ; it != y.tdomain()->end() ; it++) \ { \ auto sy = y.slice(it); \ - sy->codomain() = f(x1.slice(it)->codomain(),sy->codomain()); \ + sy->codomain() = f(x1.slice(it)->codomain(), x2.slice(it)->codomain()); \ } \ return y; \ } \ @@ -43,7 +45,7 @@ namespace codac2 for(auto it = y.tdomain()->begin() ; it != y.tdomain()->end() ; it++) \ { \ auto sy = y.slice(it); \ - sy->codomain() = f(x1,sy->codomain()); \ + sy->codomain() = f(x1, sy->codomain()); \ } \ return y; \ } \ @@ -54,7 +56,7 @@ namespace codac2 for(auto it = y.tdomain()->begin() ; it != y.tdomain()->end() ; it++) \ { \ auto sy = y.slice(it); \ - sy->codomain() = f(sy->codomain(),x2); \ + sy->codomain() = f(sy->codomain(), x2); \ } \ return y; \ } \ @@ -65,7 +67,7 @@ namespace codac2 for(auto it = x1.tdomain()->begin() ; it != x1.tdomain()->end() ; it++) \ { \ auto sx1 = x1.slice(it); \ - sx1->codomain() = f(sx1->codomain(),x2.slice(it)->codomain()); \ + sx1->codomain() = f(sx1->codomain(), x2.slice(it)->codomain()); \ } \ return x1; \ } \ @@ -75,500 +77,930 @@ namespace codac2 for(auto it = x1.tdomain()->begin() ; it != x1.tdomain()->end() ; it++) \ { \ auto sx1 = x1.slice(it); \ - sx1->codomain() = f(sx1->codomain(),x2); \ + sx1->codomain() = f(sx1->codomain(), x2); \ } \ return x1; \ } \ + template + struct is_slicedtube : std::false_type {}; + + template + struct is_slicedtube> : std::true_type {}; + + template + inline constexpr bool is_slicedtube_v = is_slicedtube>::value; + + template + concept NonSlicedTube = !is_slicedtube_v; + + template + concept NonScalarTubeCodomain = + !std::is_same_v, double> && + !std::is_same_v, Interval>; + template inline T operator_tube_union(const T& x1, const T& x2) { return x1 | x2; } template inline T operator_tube_intersection(const T& x1, const T& x2) { return x1 & x2; } - template + template inline T operator_tube_add(const X1& x1, const X2& x2) { return x1 + x2; } - template + template inline T operator_tube_sub(const X1& x1, const X2& x2) { return x1 - x2; } - template + template inline T operator_tube_mul(const X1& x1, const X2& x2) { return x1 * x2; } - template - requires (!std::is_same_v) - inline T operator_tube_mul_scal(const Interval& x1, const X2& x2) { return x1 * x2; } + template + inline T operator_tube_scal_mul(const Interval& x1, const T& x2) { return x1 * x2; } - template - inline T operator_tube_mul_scal(const X1& x1, const Interval& x2) { return x1 * x2; } + template + inline T operator_tube_mul_scal(const T& x1, const Interval& x2) { return x1 * x2; } - inline IntervalMatrix operator_tube_mul_vec(const IntervalMatrix& x1, const IntervalVector& x2) { return x1 * x2; } + inline IntervalVector operator_tube_mul_vec(const IntervalMatrix& x1, const IntervalVector& x2) { return x1 * x2; } - template + template inline T operator_tube_div(const X1& x1, const X2& x2) { return x1 / x2; } - template + template inline T operator_tube_div_scal(const X1& x1, const Interval& x2) { return x1 / x2; } /** - * \brief Operates |= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise hull-union assignment of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\sqcup[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)\sqcup[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\sqcup[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand, updated in place. + * \param x2 right operand. + * \return \p x1 after the pointwise hull-union. */ template inline SlicedTube& operator|=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_union); - /** \brief \f$[x_1](\cdot)\scup[x_2](\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise hull-union of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\sqcup[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)\sqcup[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\sqcup[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand. + * \param x2 right operand. + * \return The pointwise hull-union tube. + */ template inline SlicedTube operator|(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_union); + macro_binary_tube_tube(operator_tube_union,x1); /** - * \brief Operates &= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise intersection assignment of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\cap[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)\cap[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\cap[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand, updated in place. + * \param x2 right operand. + * \return \p x1 after the pointwise intersection. */ template inline SlicedTube& operator&=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_intersection); - /** \brief \f$[x_1](\cdot)\cap[x_2](\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise intersection of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\cap[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)\cap[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\cap[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand. + * \param x2 right operand. + * \return The pointwise intersection tube. + */ template inline SlicedTube operator&(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_intersection); + macro_binary_tube_tube(operator_tube_intersection,x1); - /** \brief \f$x1(\cdot)\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Unary plus. + * + * According to \p T, the operand is respectively denoted + * \f$[x_1](\cdot)\f$, \f$[\mathbf{x}_1](\cdot)\f$ or \f$[\mathbf{A}_1](\cdot)\f$. + * + * \param x1 operand. + * \return \p x1 unchanged. + */ template - inline const SlicedTube& operator+(const SlicedTube& x1) { + inline const SlicedTube& operator+(const SlicedTube& x1) + { return x1; } - /** \brief \f$x_1(\cdot)+x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise sum of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)+[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)+[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)+[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand. + * \param x2 right operand. + * \return The pointwise sum tube. + */ template inline SlicedTube operator+(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_add); - - /** \brief \f$x_1(\cdot)+x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + macro_binary_tube_tube(operator_tube_add,x1); + + /** + * \brief Pointwise sum of a tube and a constant object with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)+x_2\f$, + * \f$[\mathbf{x}_1](\cdot)+\mathbf{x}_2\f$ or + * \f$[\mathbf{A}_1](\cdot)+\mathbf{A}_2\f$. + * + * \param x1 left tube operand. + * \param x2 right constant operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator+(const SlicedTube& x1, const Q& x2) macro_binary_tube_real(operator_tube_add); - /** \brief \f$x+x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + /** + * \brief Pointwise sum of a constant object and a tube with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$x_1+[x_2](\cdot)\f$, + * \f$\mathbf{x}_1+[\mathbf{x}_2](\cdot)\f$ or + * \f$\mathbf{A}_1+[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left constant operand. + * \param x2 right tube operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator+(const Q& x1, const SlicedTube& x2) macro_binary_real_tube(operator_tube_add); /** - * \brief Operates += - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise addition assignment with a constant object of matching codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right constant operand. + * \return \p x1 after the pointwise addition. */ - template + template + requires NonSlicedTube inline SlicedTube& operator+=(SlicedTube& x1, const Q& x2) macro_member_binary_tube_real(operator_tube_add); /** - * \brief Operates += - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise addition assignment with a tube of the same codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right tube operand. + * \return \p x1 after the pointwise addition. */ template inline SlicedTube& operator+=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_add); - /** \brief \f$-x_1(\cdot)\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Unary minus. + * + * According to \p T, the operand is respectively denoted + * \f$[x_1](\cdot)\f$, \f$[\mathbf{x}_1](\cdot)\f$ or \f$[\mathbf{A}_1](\cdot)\f$. + * + * \param x1 operand. + * \return The pointwise opposite tube. + */ template - inline SlicedTube operator-(const SlicedTube& x1) { - return -1.*x1; + inline SlicedTube operator-(const SlicedTube& x1) + { + return -1. * x1; } - /** \brief \f$x_1(\cdot)-x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise difference of two tubes with the same codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)-[x_2](\cdot)\f$, + * \f$[\mathbf{x}_1](\cdot)-[\mathbf{x}_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)-[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left operand. + * \param x2 right operand. + * \return The pointwise difference tube. + */ template inline SlicedTube operator-(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_sub); - - /** \brief \f$x_1(\cdot)-x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + macro_binary_tube_tube(operator_tube_sub,x1); + + /** + * \brief Pointwise difference between a tube and a constant object with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)-x_2\f$, + * \f$[\mathbf{x}_1](\cdot)-\mathbf{x}_2\f$ or + * \f$[\mathbf{A}_1](\cdot)-\mathbf{A}_2\f$. + * + * \param x1 left tube operand. + * \param x2 right constant operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator-(const SlicedTube& x1, const Q& x2) macro_binary_tube_real(operator_tube_sub); - /** \brief \f$x-x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + /** + * \brief Pointwise difference between a constant object and a tube with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$x_1-[x_2](\cdot)\f$, + * \f$\mathbf{x}_1-[\mathbf{x}_2](\cdot)\f$ or + * \f$\mathbf{A}_1-[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left constant operand. + * \param x2 right tube operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator-(const Q& x1, const SlicedTube& x2) macro_binary_real_tube(operator_tube_sub); /** - * \brief Operates -= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise subtraction assignment with a constant object of matching codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right constant operand. + * \return \p x1 after the pointwise subtraction. */ - template + template + requires NonSlicedTube inline SlicedTube& operator-=(SlicedTube& x1, const Q& x2) macro_member_binary_tube_real(operator_tube_sub); /** - * \brief Operates -= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise subtraction assignment with a tube of the same codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right tube operand. + * \return \p x1 after the pointwise subtraction. */ template inline SlicedTube& operator-=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_sub); - /** \brief \f$x_1\cdot x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise multiplication of a scalar interval and a tube. + * + * According to \p T, the operation is respectively + * \f$x_1\,[x_2](\cdot)\f$, + * \f$x_1\,[\mathbf{x}_2](\cdot)\f$ or + * \f$x_1\,[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 scalar interval. + * \param x2 right tube operand. + * \return The resulting tube. + */ template - requires (!std::is_same_v) + requires (!std::is_same_v) inline SlicedTube operator*(const Interval& x1, const SlicedTube& x2) - macro_binary_real_tube(operator_tube_mul_scal); + macro_binary_real_tube(operator_tube_scal_mul); - /** \brief \f$x_1(\cdot)\cdot x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise multiplication of a tube by a scalar interval. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\,x_2\f$, + * \f$[\mathbf{x}_1](\cdot)\,x_2\f$ or + * \f$[\mathbf{A}_1](\cdot)\,x_2\f$. + * + * \param x1 left tube operand. + * \param x2 scalar interval. + * \return The resulting tube. + */ template - requires (!std::is_same_v) + requires (!std::is_same_v) inline SlicedTube operator*(const SlicedTube& x1, const Interval& x2) macro_binary_tube_real(operator_tube_mul_scal); - /** \brief \f$x_1(\cdot)\cdot x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise multiplication of two scalar interval tubes. + * + * \f$[x_1](\cdot)\,[x_2](\cdot)\f$ + * + * \param x1 left operand. + * \param x2 right operand. + * \return The resulting scalar interval tube. + */ + inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_mul,x1); + + /** + * \brief Pointwise multiplication of two interval-vector tubes. + * + * \f$[\mathbf{x}_1](\cdot)\,[\mathbf{x}_2](\cdot)\f$ + * + * \param x1 left operand. + * \param x2 right operand. + * \return The resulting interval-vector tube. + */ + inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_mul,x1); + + /** + * \brief Pointwise multiplication of two interval-matrix tubes. + * + * \f$[\mathbf{A}_1](\cdot)\,[\mathbf{A}_2](\cdot)\f$ + * + * \param x1 left operand. + * \param x2 right operand. + * \return The resulting interval-matrix tube. + */ + inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_mul,x1); + + /** + * \brief Pointwise multiplication of a scalar interval tube and a non-scalar tube. + * + * Depending on \p T, the operation is + * \f$[x_1](\cdot)\,[\mathbf{x}_2](\cdot)\f$ or + * \f$[x_1](\cdot)\,[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 scalar interval tube. + * \param x2 non-scalar tube operand. + * \return The resulting tube. + */ template - inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_mul); - - /** \brief \f$x_1(\cdot)\cdot x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + requires NonScalarTubeCodomain + inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_mul,x2); + + /** + * \brief Pointwise multiplication of a non-scalar tube and a scalar interval tube. + * + * Depending on \p T, the operation is + * \f$[\mathbf{x}_1](\cdot)\,[x_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\,[x_2](\cdot)\f$. + * + * \param x1 non-scalar tube operand. + * \param x2 scalar interval tube. + * \return The resulting tube. + */ + template + requires NonScalarTubeCodomain + inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_mul,x1); + + /** + * \brief Pointwise multiplication of a tube and a constant object with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)\,x_2\f$, + * \f$[\mathbf{x}_1](\cdot)\,\mathbf{x}_2\f$ or + * \f$[\mathbf{A}_1](\cdot)\,\mathbf{A}_2\f$. + * + * \param x1 left tube operand. + * \param x2 right constant operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator*(const SlicedTube& x1, const Q& x2) macro_binary_tube_real(operator_tube_mul); - /** \brief \f$x\cdot x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + /** + * \brief Pointwise multiplication of a constant object and a tube with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$x_1\,[x_2](\cdot)\f$, + * \f$\mathbf{x}_1\,[\mathbf{x}_2](\cdot)\f$ or + * \f$\mathbf{A}_1\,[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 left constant operand. + * \param x2 right tube operand. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator*(const Q& x1, const SlicedTube& x2) macro_binary_real_tube(operator_tube_mul); - /** \brief \f$x_1(\cdot)\cdot x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise multiplication of an interval-matrix tube by an interval-vector tube. + * + * \f$[\mathbf{A}_1](\cdot)\,[\mathbf{x}_2](\cdot)\f$ + * + * \param x1 interval-matrix tube. + * \param x2 interval-vector tube. + * \return The resulting interval-vector tube. + */ inline SlicedTube operator*(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_mul_vec); + macro_binary_tube_tube(operator_tube_mul_vec,x2); /** - * \brief Operates *= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise multiplication assignment with a constant object of matching codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right constant operand. + * \return \p x1 after the pointwise multiplication. */ - template + template + requires NonSlicedTube inline SlicedTube& operator*=(SlicedTube& x1, const Q& x2) macro_member_binary_tube_real(operator_tube_mul); /** - * \brief Operates *= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise multiplication assignment with a tube of the same codomain type. + * + * \param x1 left tube operand, updated in place. + * \param x2 right tube operand. + * \return \p x1 after the pointwise multiplication. */ template inline SlicedTube& operator*=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_mul); - /** \brief \f$x_2(\cdot)/x_1\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise multiplication assignment by a scalar interval tube. + * + * Depending on \p T, the operation is + * \f$[\mathbf{x}_1](\cdot)\,[x_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)\,[x_2](\cdot)\f$. + * + * \param x1 non-scalar tube operand, updated in place. + * \param x2 scalar interval tube. + * \return \p x1 after the pointwise multiplication. + */ + template + requires NonScalarTubeCodomain + inline SlicedTube& operator*=(SlicedTube& x1, const SlicedTube& x2) + macro_member_binary_tube_tube(operator_tube_mul); + + /** + * \brief Pointwise division of a tube by a scalar interval. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)/x_2\f$, + * \f$[\mathbf{x}_1](\cdot)/x_2\f$ or + * \f$[\mathbf{A}_1](\cdot)/x_2\f$. + * + * \param x1 numerator tube. + * \param x2 scalar interval denominator. + * \return The resulting tube. + */ template - requires (!std::is_same_v) + requires (!std::is_same_v) inline SlicedTube operator/(const SlicedTube& x1, const Interval& x2) macro_binary_tube_real(operator_tube_div_scal); - /** \brief \f$x_1(\cdot)/x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise division of two scalar interval tubes. + * + * \f$[x_1](\cdot)/[x_2](\cdot)\f$ + * + * \param x1 numerator tube. + * \param x2 denominator tube. + * \return The resulting scalar interval tube. + */ + inline SlicedTube operator/(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_div,x1); + + /** + * \brief Pointwise division of a non-scalar tube by a scalar interval tube. + * + * Depending on \p T, the operation is + * \f$[\mathbf{x}_1](\cdot)/[x_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)/[x_2](\cdot)\f$. + * + * \param x1 non-scalar numerator tube. + * \param x2 scalar interval denominator tube. + * \return The resulting tube. + */ template - inline SlicedTube operator/(const SlicedTube& x1, const SlicedTube& x2) - macro_binary_tube_tube(operator_tube_div); - - /** \brief \f$x_1(\cdot)/x_2\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + requires NonScalarTubeCodomain + inline SlicedTube operator/(const SlicedTube& x1, const SlicedTube& x2) + macro_binary_tube_tube(operator_tube_div,x1); + + /** + * \brief Pointwise division of a tube by a constant object with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$[x_1](\cdot)/x_2\f$, + * \f$[\mathbf{x}_1](\cdot)/\mathbf{x}_2\f$ or + * \f$[\mathbf{A}_1](\cdot)/\mathbf{A}_2\f$. + * + * \param x1 numerator tube. + * \param x2 denominator constant object. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator/(const SlicedTube& x1, const Q& x2) macro_binary_tube_real(operator_tube_div); - /** \brief \f$x/x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ - template + /** + * \brief Pointwise division of a constant object by a tube with matching codomain type. + * + * According to \p T, the operation is respectively + * \f$x_1/[x_2](\cdot)\f$, + * \f$\mathbf{x}_1/[\mathbf{x}_2](\cdot)\f$ or + * \f$\mathbf{A}_1/[\mathbf{A}_2](\cdot)\f$. + * + * \param x1 numerator constant object. + * \param x2 denominator tube. + * \return The resulting tube. + */ + template + requires NonSlicedTube inline SlicedTube operator/(const Q& x1, const SlicedTube& x2) macro_binary_real_tube(operator_tube_div); /** - * \brief Operates /= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise division assignment with a constant object of matching codomain type. + * + * \param x1 numerator tube, updated in place. + * \param x2 denominator constant object. + * \return \p x1 after the pointwise division. */ - template + template + requires NonSlicedTube inline SlicedTube& operator/=(SlicedTube& x1, const Q& x2) macro_member_binary_tube_real(operator_tube_div); /** - * \brief Operates /= - * \param x1 - * \param x2 - * \return updated output + * \brief Pointwise division assignment with a tube of the same codomain type. + * + * \param x1 numerator tube, updated in place. + * \param x2 denominator tube. + * \return \p x1 after the pointwise division. */ template inline SlicedTube& operator/=(SlicedTube& x1, const SlicedTube& x2) macro_member_binary_tube_tube(operator_tube_div); - /** \brief \f$x^2(\cdot)\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise division assignment by a scalar interval tube. + * + * Depending on \p T, the operation is + * \f$[\mathbf{x}_1](\cdot)/[x_2](\cdot)\f$ or + * \f$[\mathbf{A}_1](\cdot)/[x_2](\cdot)\f$. + * + * \param x1 non-scalar numerator tube, updated in place. + * \param x2 scalar interval denominator tube. + * \return \p x1 after the pointwise division. + */ + template + requires NonScalarTubeCodomain + inline SlicedTube& operator/=(SlicedTube& x1, const SlicedTube& x2) + macro_member_binary_tube_tube(operator_tube_div); + + /** + * \brief Pointwise square of a scalar interval tube. + * + * \f$\big([x_1](\cdot)\big)^2\f$ + * + * \param x1 scalar interval tube. + * \return The squared tube. + */ SlicedTube sqr(const SlicedTube& x1); - /** \brief \f$\sqrt{x_1(\cdot)}\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise square root of a scalar interval tube. + * + * \f$\sqrt{[x_1](\cdot)}\f$ + * + * \param x1 scalar interval tube. + * \return The square-root tube. + */ SlicedTube sqrt(const SlicedTube& x1); - /** \brief \f$x^x_2(\cdot)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise power of a scalar interval tube with an integer exponent. + * + * \f$\big([x_1](\cdot)\big)^{x_2}\f$ + * + * \param x1 scalar interval tube. + * \param x2 integer exponent. + * \return The resulting tube. + */ + SlicedTube pow(const SlicedTube& x1, int x2); + + /** + * \brief Pointwise power of a scalar interval tube with an interval exponent. + * + * \f$\big([x_1](\cdot)\big)^{x_2}\f$ + * + * \param x1 scalar interval tube. + * \param x2 interval exponent. + * \return The resulting tube. + */ SlicedTube pow(const SlicedTube& x1, const Interval& x2); - /** \brief \f$\exp(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise exponential of a scalar interval tube. + * + * \f$\exp\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube exp(const SlicedTube& x1); - /** \brief \f$\log(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise natural logarithm of a scalar interval tube. + * + * \f$\log\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube log(const SlicedTube& x1); - /** \brief \f$\cos(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise cosine of a scalar interval tube. + * + * \f$\cos\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube cos(const SlicedTube& x1); - /** \brief \f$\sin(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise sine of a scalar interval tube. + * + * \f$\sin\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube sin(const SlicedTube& x1); - /** \brief \f$\tan(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise tangent of a scalar interval tube. + * + * \f$\tan\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube tan(const SlicedTube& x1); - /** \brief \f$\arccos(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise arc-cosine of a scalar interval tube. + * + * \f$\arccos\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube acos(const SlicedTube& x1); - /** \brief \f$\arcsin(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise arc-sine of a scalar interval tube. + * + * \f$\arcsin\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube asin(const SlicedTube& x1); - /** \brief \f$\arctan(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise arc-tangent of a scalar interval tube. + * + * \f$\arctan\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube atan(const SlicedTube& x1); - /** \brief \f$\mathrm{arctan2}(x_1(\cdot),x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise two-argument arc-tangent of two scalar interval tubes. + * + * \f$\operatorname{atan2}\!\big([x_1](\cdot),[x_2](\cdot)\big)\f$ + * + * \param x1 first scalar interval tube. + * \param x2 second scalar interval tube. + * \return The resulting tube. + */ SlicedTube atan2(const SlicedTube& x1, const SlicedTube& x2); - /** \brief \f$\mathrm{arctan2}(x_1(\cdot),x_2)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise two-argument arc-tangent of a scalar interval tube and an interval. + * + * \f$\operatorname{atan2}\!\big([x_1](\cdot),x_2\big)\f$ + * + * \param x1 scalar interval tube. + * \param x2 scalar interval. + * \return The resulting tube. + */ SlicedTube atan2(const SlicedTube& x1, const Interval& x2); - /** \brief \f$\mathrm{arctan2}(x_1, x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise two-argument arc-tangent of an interval and a scalar interval tube. + * + * \f$\operatorname{atan2}\!\big(x_1,[x_2](\cdot)\big)\f$ + * + * \param x1 scalar interval. + * \param x2 scalar interval tube. + * \return The resulting tube. + */ SlicedTube atan2(const Interval& x1, const SlicedTube& x2); - /** \brief \f$\cosh(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise hyperbolic cosine of a scalar interval tube. + * + * \f$\cosh\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube cosh(const SlicedTube& x1); - /** \brief \f$\sinh(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise hyperbolic sine of a scalar interval tube. + * + * \f$\sinh\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube sinh(const SlicedTube& x1); - /** \brief \f$\tanh(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise hyperbolic tangent of a scalar interval tube. + * + * \f$\tanh\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube tanh(const SlicedTube& x1); - /** \brief \f$\mathrm{arccosh}(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise inverse hyperbolic cosine of a scalar interval tube. + * + * \f$\operatorname{arccosh}\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube acosh(const SlicedTube& x1); - /** \brief \f$\mathrm{arcsinh}(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise inverse hyperbolic sine of a scalar interval tube. + * + * \f$\operatorname{arcsinh}\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube asinh(const SlicedTube& x1); - /** \brief \f$\mathrm{arctanh}(x_1(\cdot))\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise inverse hyperbolic tangent of a scalar interval tube. + * + * \f$\operatorname{arctanh}\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube atanh(const SlicedTube& x1); - /** \brief \f$\mid x_1(\cdot)\mid\f$ - * \param x1 - * \return tube output - */ + /** + * \brief Pointwise absolute value of a scalar interval tube. + * + * \f$\left|[x_1](\cdot)\right|\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube abs(const SlicedTube& x1); - /** \brief \f$\min(x_1(\cdot),x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise minimum of two scalar interval tubes. + * + * \f$\min\!\big([x_1](\cdot),[x_2](\cdot)\big)\f$ + * + * \param x1 first scalar interval tube. + * \param x2 second scalar interval tube. + * \return The resulting tube. + */ SlicedTube min(const SlicedTube& x1, const SlicedTube& x2); - /** \brief \f$\min(x_1(\cdot),x_2)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise minimum of a scalar interval tube and an interval. + * + * \f$\min\!\big([x_1](\cdot),x_2\big)\f$ + * + * \param x1 scalar interval tube. + * \param x2 scalar interval. + * \return The resulting tube. + */ SlicedTube min(const SlicedTube& x1, const Interval& x2); - /** \brief \f$\min(x_1, x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise minimum of an interval and a scalar interval tube. + * + * \f$\min\!\big(x_1,[x_2](\cdot)\big)\f$ + * + * \param x1 scalar interval. + * \param x2 scalar interval tube. + * \return The resulting tube. + */ SlicedTube min(const Interval& x1, const SlicedTube& x2); - /** \brief \f$\max(x_1(\cdot),x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise maximum of two scalar interval tubes. + * + * \f$\max\!\big([x_1](\cdot),[x_2](\cdot)\big)\f$ + * + * \param x1 first scalar interval tube. + * \param x2 second scalar interval tube. + * \return The resulting tube. + */ SlicedTube max(const SlicedTube& x1, const SlicedTube& x2); - /** \brief \f$\max(x_1(\cdot),x_2)\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise maximum of a scalar interval tube and an interval. + * + * \f$\max\!\big([x_1](\cdot),x_2\big)\f$ + * + * \param x1 scalar interval tube. + * \param x2 scalar interval. + * \return The resulting tube. + */ SlicedTube max(const SlicedTube& x1, const Interval& x2); - /** \brief \f$\max(x_1, x_2(\cdot))\f$ - * \param x1 - * \param x2 - * \return tube output - */ + /** + * \brief Pointwise maximum of an interval and a scalar interval tube. + * + * \f$\max\!\big(x_1,[x_2](\cdot)\big)\f$ + * + * \param x1 scalar interval. + * \param x2 scalar interval tube. + * \return The resulting tube. + */ SlicedTube max(const Interval& x1, const SlicedTube& x2); + /** + * \brief Pointwise sign of a scalar interval tube. + * + * \f$\operatorname{sign}\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube sign(const SlicedTube& x1); + /** + * \brief Pointwise integer-part operator applied to a scalar interval tube. + * + * \f$\operatorname{integer}\!\big([x_1](\cdot)\big)\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube integer(const SlicedTube& x1); + /** + * \brief Pointwise floor of a scalar interval tube. + * + * \f$\lfloor [x_1](\cdot) \rfloor\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube floor(const SlicedTube& x1); + /** + * \brief Pointwise ceiling of a scalar interval tube. + * + * \f$\lceil [x_1](\cdot) \rceil\f$ + * + * \param x1 scalar interval tube. + * \return The resulting tube. + */ SlicedTube ceil(const SlicedTube& x1); } \ No newline at end of file From 50fafdc648ebb1e41e0259423ec2b5d1954eb5e8 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:11:42 +0200 Subject: [PATCH 10/21] [traj] minor update, include files --- src/core/trajectory/codac2_AnalyticTraj.h | 2 ++ src/core/trajectory/codac2_SampledTraj.h | 2 ++ src/core/trajectory/codac2_TrajBase.h | 4 +--- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/core/trajectory/codac2_AnalyticTraj.h b/src/core/trajectory/codac2_AnalyticTraj.h index 37b9944cd..eb98e4a25 100644 --- a/src/core/trajectory/codac2_AnalyticTraj.h +++ b/src/core/trajectory/codac2_AnalyticTraj.h @@ -89,3 +89,5 @@ namespace codac2 Interval _tdomain; }; } + +#include "codac2_TrajBase_impl.h" \ No newline at end of file diff --git a/src/core/trajectory/codac2_SampledTraj.h b/src/core/trajectory/codac2_SampledTraj.h index ba247b3c7..82e9f8752 100644 --- a/src/core/trajectory/codac2_SampledTraj.h +++ b/src/core/trajectory/codac2_SampledTraj.h @@ -453,3 +453,5 @@ namespace codac2 return v; } } + +#include "codac2_TrajBase_impl.h" \ No newline at end of file diff --git a/src/core/trajectory/codac2_TrajBase.h b/src/core/trajectory/codac2_TrajBase.h index 3abb4027a..46e12f645 100644 --- a/src/core/trajectory/codac2_TrajBase.h +++ b/src/core/trajectory/codac2_TrajBase.h @@ -43,6 +43,4 @@ namespace codac2 SampledTraj sampled_as(const SampledTraj& x) const; SampledTraj primitive(double dt) const; }; -} - -#include "codac2_TrajBase_impl.h" \ No newline at end of file +} \ No newline at end of file From 2d54c20ec06964c8897f7dd0370f72e4bff7689c Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:12:00 +0200 Subject: [PATCH 11/21] [py] wrapper for SampledTraj --- python/codac/core/__init__.py | 63 +++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/python/codac/core/__init__.py b/python/codac/core/__init__.py index a840c9d31..45f43fff0 100644 --- a/python/codac/core/__init__.py +++ b/python/codac/core/__init__.py @@ -9,6 +9,11 @@ import sys import warnings +try: + import numpy as _np +except ImportError: + _np = None + def codac_error(message): print(f''' @@ -41,6 +46,12 @@ def codac_error(message): AnalyticTraj_Matrix, ) +_SAMPLED_TRAJ_TYPES = ( + SampledTraj_Scalar, + SampledTraj_Vector, + SampledTraj_Matrix, +) + def _is_scalar_expr_like(x): return isinstance(x, (int, float, Interval, ScalarVar, ScalarExpr)) @@ -307,6 +318,58 @@ def traj_cart_prod(*x): return traj_cart_prod_list([*x]) +def _sampled_traj_type_and_value(x): + if isinstance(x, (int, float)): + return SampledTraj_Scalar, float + + if isinstance(x, Vector) \ + or (_np is not None and isinstance(x, _np.ndarray) and x.ndim == 1) \ + or (isinstance(x, (list, tuple)) and (len(x) == 0 or not isinstance(x[0], (list, tuple)))): + return SampledTraj_Vector, lambda y: y if isinstance(y, Vector) else Vector(y) + + if isinstance(x, Matrix) \ + or (_np is not None and isinstance(x, _np.ndarray) and x.ndim == 2) \ + or (isinstance(x, (list, tuple)) and len(x) > 0 and isinstance(x[0], (list, tuple))): + return SampledTraj_Matrix, lambda y: y if isinstance(y, Matrix) else Matrix(y) + + return None, None + + +def SampledTraj(x=None, y=None): + if y is None: + if x is None: + codac_error("SampledTraj: unable to deduce the trajectory type from an empty constructor") + + for cls in _SAMPLED_TRAJ_TYPES: + if isinstance(x, cls): + return cls(dict(x)) + + if isinstance(x, dict): + if not x: + codac_error("SampledTraj: unable to deduce the trajectory type from an empty map") + cls, cast = _sampled_traj_type_and_value(next(iter(x.values()))) + if cls is None: + codac_error("SampledTraj: wrong constructor argument") + return cls({float(t): cast(v) for t, v in x.items()}) + + codac_error("SampledTraj: wrong constructor argument") + + if len(y) == 0: + codac_error("SampledTraj: unable to deduce the trajectory type from empty samples") + + cls, cast = _sampled_traj_type_and_value(y[0]) + if cls is None: + codac_error("SampledTraj: unable to deduce the trajectory type from the provided samples") + + if cls is SampledTraj_Scalar: + return cls(list(x), [float(v) for v in y]) + + if cls is SampledTraj_Vector and _np is not None and isinstance(x, _np.ndarray) and isinstance(y, _np.ndarray): + return cls(x, y) + + return cls({float(t): cast(v) for t, v in zip(x, y)}) + + def AnalyticTraj(f, t): f = AnalyticFunction(f) From c6eff6a5a76c05fc674dd454ee6fdddcf9c253a9 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:12:21 +0200 Subject: [PATCH 12/21] [doc] figure captions in italic --- doc/manual/_static/css/custom.css | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/manual/_static/css/custom.css b/doc/manual/_static/css/custom.css index 15d67c7a3..44a8b663a 100644 --- a/doc/manual/_static/css/custom.css +++ b/doc/manual/_static/css/custom.css @@ -191,4 +191,9 @@ a .download:before { .sidebar-tree li.toctree-l1 > a.reference.internal.current:has(+ input#toctree-checkbox-9) { background: url("../logos/logos_vibes_ipe.png") no-repeat center / contain, var(--color-sidebar-item-background--current); +} + +figcaption .caption-text +{ + font-style: italic; } \ No newline at end of file From 92bf13a4a98585a4a8766285b3b22bea00e76a52 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:12:53 +0200 Subject: [PATCH 13/21] [doc] Codac2: towards official release --- doc/manual/conf.py.in | 2 +- doc/manual/index.rst | 7 +++---- doc/manual/manual/installation/cpp.rst | 2 +- doc/manual/manual/installation/matlab.rst | 3 +-- doc/manual/manual/installation/python.rst | 12 +++++------- 5 files changed, 11 insertions(+), 15 deletions(-) diff --git a/doc/manual/conf.py.in b/doc/manual/conf.py.in index 31f65d821..8c92a6019 100644 --- a/doc/manual/conf.py.in +++ b/doc/manual/conf.py.in @@ -89,7 +89,7 @@ html_theme_options = { "color-toc-item-text--active": "#FFFFFF", }, - "announcement": "You are currently reading the new Codac documentation, which is currently in preparation. See the v1 website.", + #"announcement": "You are currently reading the new Codac documentation, which is currently in preparation. See the v1 website.", } # See https://www.sympy.org/sphinx-math-dollar/ diff --git a/doc/manual/index.rst b/doc/manual/index.rst index eab110345..8c38197fd 100644 --- a/doc/manual/index.rst +++ b/doc/manual/index.rst @@ -213,10 +213,9 @@ User manual * The class SetMembershipFunction * Extension to custom expressions -* Tubes - * What is a tube? - * Temporal domains - * The Tube classes +* :ref:`sec-domains-tubes` + * :ref:`sec-domains-tubes-tdomain` + * :ref:`sec-domains-tubes-slicedtube` * The Trajectory classes * Increasing performances using views diff --git a/doc/manual/manual/installation/cpp.rst b/doc/manual/manual/installation/cpp.rst index 1b97da510..9f0399474 100644 --- a/doc/manual/manual/installation/cpp.rst +++ b/doc/manual/manual/installation/cpp.rst @@ -190,7 +190,7 @@ Optionally, for Python binding (*e.g.* ``choco install python --version=3.10.4`` .. code-block:: bash - choco install doxygen.install --version=1.13 + choco install doxygen.install --version=1.16 choco install graphviz python -m pip install --upgrade pip pip install --upgrade wheel setuptools sphinx sphinx_rtd_theme furo sphinx-math-dollar sphinx_tabs breathe sphinx_togglebutton diff --git a/doc/manual/manual/installation/matlab.rst b/doc/manual/manual/installation/matlab.rst index 696797f78..0fe6071fe 100644 --- a/doc/manual/manual/installation/matlab.rst +++ b/doc/manual/manual/installation/matlab.rst @@ -13,8 +13,7 @@ Since 2019, MATLAB allows you to import Python packages into its environment. Co .. code-block:: bash - pip install codac4matlab --pre - # Option --pre has to be set because Codac v2 is only available in pre-release + pip install codac4matlab Once Codac is installed, you can use it in your MATLAB scripts using the following import command: diff --git a/doc/manual/manual/installation/python.rst b/doc/manual/manual/installation/python.rst index d06aee3a1..0cdcfeb2c 100644 --- a/doc/manual/manual/installation/python.rst +++ b/doc/manual/manual/installation/python.rst @@ -7,22 +7,20 @@ Python installation In case you want to use Codac only with Python, then the installation procedure is simply: -1. **Dependencies**: Ensure you have a supported version of Python (>=3.6). +1. **Dependencies**: Ensure you have a supported version of Python (>=3.8). 2. **Install via pip**: Use the following command to install Codac: .. code-block:: bash - pip install codac --pre - # Option --pre has to be set because Codac v2 is only available in pre-release + pip install codac -You can also update and test your Codac Python package. +You can also update and test your Codac Python package: * **Update via pip**: Use the following command to update your already installed Codac package: .. code-block:: bash - pip install codac --upgrade --pre - # Option --pre has to be set because Codac v2 is only available in pre-release + pip install codac --upgrade * **Testing the installation**: In order to verify that your installation is working properly in Python, you can run: @@ -42,7 +40,7 @@ Depending on your configuration, you may encounter difficulties when installing .. code-block:: bash - pip3 install --break-system-packages codac --pre + pip3 install --break-system-packages codac .. admonition:: macOS Big Sur and later (x86_64) From 0d10064476cad0fa278eb84310a31c71c6ea658c Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 15:13:33 +0200 Subject: [PATCH 14/21] [doc] updated documentation of tubes (separated code) --- doc/manual/manual/tubes/index.rst | 3 +- doc/manual/manual/tubes/slicedtube.rst | 315 ++++++++++--------------- doc/manual/manual/tubes/src.cpp | 248 +++++++++++++++++++ doc/manual/manual/tubes/src.py | 212 +++++++++++++++++ doc/manual/manual/tubes/tdomain.rst | 151 ++++-------- tests/CMakeLists.txt | 3 +- 6 files changed, 641 insertions(+), 291 deletions(-) create mode 100644 doc/manual/manual/tubes/src.cpp create mode 100644 doc/manual/manual/tubes/src.py diff --git a/doc/manual/manual/tubes/index.rst b/doc/manual/manual/tubes/index.rst index 885fc32c3..e1baee6dc 100644 --- a/doc/manual/manual/tubes/index.rst +++ b/doc/manual/manual/tubes/index.rst @@ -34,6 +34,7 @@ The library naturally provides and primarily uses: * ``SlicedTube``. These are the most common tube types in practice. In Python and Matlab, only these standard sliced-tube classes are currently exposed through the bindings. +In C++, instantiations such as ``SlicedTube`` are allowed, provided the required tube operations are available for that domain. This chapter documents the *sliced tube* implementation currently available in Codac. In this implementation, a tube is represented over an explicit temporal partition stored in a :class:`~codac.TDomain`. Each temporal element is a :class:`~codac.TSlice`, and each application-level value over one temporal element is represented by a :class:`~codac.Slice`. The main user-facing object is therefore a :class:`~codac.SlicedTube`. @@ -42,7 +43,7 @@ This chapter documents the *sliced tube* implementation currently available in C An example of sliced tube :math:`[x](\cdot)`, as implemented in Codac. The tube is made as a list of interval or box slices. In practice, the sampling :math:`\delta` is not necessarily constant. -Compared with the previous Codac v1 implementation, these tubes are not only functions of time: they are also shared data structures built on a common temporal partition. Refining the time partition of one tube may therefore update the internal slice structure of all tubes attached to the same :class:`~codac.TDomain`. This design is central to the current implementation. It simplifies the user experience: a temporal modification applied to one tube is implicitly propagated to the others, so multi-tube operations such as arithmetic combinations or contractions can still be performed easily on a consistent shared time basis. +Compared with the previous Codac v1 implementation, these tubes are not only functions of time: they also have shared data structures built on a common temporal partition. Refining the time partition of one tube may therefore update the internal slice structure of all tubes attached to the same :class:`~codac.TDomain`. This design is central to the current implementation. It simplifies the user experience: a temporal modification applied to one tube is implicitly propagated to the others, so multi-tube operations such as arithmetic combinations or contractions can still be performed easily on a consistent shared time basis. Conceptually, the data model is: diff --git a/doc/manual/manual/tubes/slicedtube.rst b/doc/manual/manual/tubes/slicedtube.rst index 19714943c..87202c2ae 100644 --- a/doc/manual/manual/tubes/slicedtube.rst +++ b/doc/manual/manual/tubes/slicedtube.rst @@ -1,4 +1,4 @@ -.. _sec-domains-slicedtube: +.. _sec-domains-tubes-slicedtube: The SlicedTube class ==================== @@ -35,55 +35,19 @@ A sliced tube can be created from: .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,10], 0.1, True) - - # Sliced tube from interval-type codomains - x = SlicedTube(td, Interval(-1,1)) - y = SlicedTube(td, IntervalVector(2)) - z = SlicedTube(td, IntervalMatrix(2,2)) - - # From an analytic function - t = ScalarVar() - f = AnalyticFunction([t], sin(t)) - xf = SlicedTube(td, f) - - # From an analytic trajectory or sampled trajectory - at = AnalyticTraj(AnalyticFunction([t],cos(t)), [0,10]) - st = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), [0,10]).sampled(1e-2) - xu = SlicedTube(td,at) | SlicedTube(td,st) # union (hull) of tubes - - fig.plot_tube(xf, [Color.dark_blue(),Color.light_gray()]) - fig.plot_tube(xu, [Color.dark_blue(),Color.light_gray()]) + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-1-beg] + :end-before: [slicedtube-class-1-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,10}, 0.1, true); - - // Sliced tube from interval-type codomains - SlicedTube x(td, Interval(-1,1)); // x has type SlicedTube - SlicedTube y(td, IntervalVector(2)); // y has type SlicedTube - SlicedTube z(td, IntervalMatrix(2,2)); // z has type SlicedTube - - // Explicit template notation remains possible: - SlicedTube x2(td, Interval(-1,1)); - - // From an analytic function - ScalarVar t; - AnalyticFunction f({t}, sin(t)); - SlicedTube xf(td, f); - // xf has type SlicedTube because f outputs scalar values - - // From an analytic trajectory or sampled trajectory - AnalyticTraj at(AnalyticFunction({t},cos(t)), {0,10}); - AnalyticTraj st(AnalyticFunction({t},cos(t)+t/10), {0,10}).sampled(1e-2); - auto xu = SlicedTube(td,at) | SlicedTube(td,st); // union (hull) of tubes - - fig.plot_tube(xf, {Color::dark_blue(),Color::light_gray()}); - fig.plot_tube(xu, {Color::dark_blue(),Color::light_gray()}); + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-1-beg] + :end-before: [slicedtube-class-1-end] + :dedent: 4 .. figure:: interval_trajs.png @@ -120,35 +84,19 @@ The class also defines custom iterators so that iterating on a ``SlicedTube`` yi .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,3]) - x = SlicedTube(td, IntervalVector(2)) - x.set([[1,5],[-oo,2]], [0,1]) - x.set([[2,8],[-oo,3]], [1,2]) - x.set([[6,9],[-oo,4]], [2,3]) - - s0 = x.first_slice() - s1 = s0.next_slice() - - for s in x: - print(s.t0_tf(), s.codomain()) + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-2-beg] + :end-before: [slicedtube-class-2-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,3}); - SlicedTube x(td, IntervalVector(2)); - x.set({{1,5},{-oo,2}}, {0,1}); - x.set({{2,8},{-oo,3}}, {1,2}); - x.set({{6,9},{-oo,4}}, {2,3}); - - auto s0 = x.first_slice(); - auto s1 = s0->next_slice(); - - for(const auto& s : x) - std::cout << s.t0_tf() << " -> " << s.codomain() << std::endl; + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-2-beg] + :end-before: [slicedtube-class-2-end] + :dedent: 4 Setting values and refining the partition @@ -172,41 +120,19 @@ For example, setting a value at one scalar time creates an explicit gate if nece .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,2], 1.0, False) # False: without gates - - x = SlicedTube(td, Interval(0,1)) - v = SlicedTube(td, Interval(-1,1)) - - print(x) # outputs [0,2]↦[0,1], 2 slices - print(v) # outputs [0,2]↦[0,1], 2 slices - - td.nb_tslices() # 2: [0,1],[1,2] - x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 - td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] - - print(x) # outputs [0,2]↦[-1,1], 4 slices - print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-4-beg] + :end-before: [tdomain-class-4-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,2}, 1.0, false); // false: without gates - - SlicedTube x(td, Interval(0,1)); - SlicedTube v(td, Interval(-1,1)); - - cout << x << endl; // outputs [0,2]↦[0,1], 2 slices - cout << v << endl; // outputs [0,2]↦[0,1], 2 slices - - td->nb_tslices(); // 2: [0,1],[1,2] - x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 - td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] - - cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices - cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-4-beg] + :end-before: [tdomain-class-4-end] + :dedent: 4 Evaluation @@ -220,45 +146,19 @@ When a derivative tube ``v`` is available, the overload ``x(t,v)`` uses per-slic .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,3], 1.0, False) - x = SlicedTube(td, Interval()) - - x.set([1,5], [0,1]) - x.set([2,8], [1,2]) - x.set([6,9], [2,3]) - - x(0.5) # [1,5] - x(1.5) # [2,8] - x([0,3]) # [1,9] - x(-1.0) # [-oo,oo] - - # No explicit gates: boundary values come from adjacent-slice intersections - x(1.0) # [2,5] - x(2.0) # [6,8] - x(3.0) # [6,9] + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-4-beg] + :end-before: [slicedtube-class-4-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,3}, 1.0, false); - SlicedTube x(td, Interval()); - - x.set({1,5}, {0,1}); - x.set({2,8}, {1,2}); - x.set({6,9}, {2,3}); - - Interval y0 = x(0.5); // [1,5] - Interval y1 = x(1.5); // [2,8] - Interval y2 = x({0,3}); // [1,9] - Interval y3 = x(-1.0); // [-oo,oo] - - // No explicit gates: boundary values come from adjacent-slice intersections - Interval y4 = x(1.0); // [2,5] - Interval y5 = x(2.0); // [6,8] - Interval y6 = x(3.0); // [6,9] + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-4-beg] + :end-before: [slicedtube-class-4-end] + :dedent: 4 Inversion @@ -296,29 +196,20 @@ The following example computes the different connected components of the inversi .. group-tab:: Python - .. code-block:: py - - v_t = [] - y = Interval(0,0.2) - x.invert(y,v_t) - - for t in v_t: - z = cart_prod(t,y) - DefaultFigure.draw_box(z, Color.red()) + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-5-beg] + :end-before: [slicedtube-class-5-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-5-beg] + :end-before: [slicedtube-class-5-end] + :dedent: 4 - std::vector v_t; - Interval y(0,0.2); - x.invert(y, v_t); - - for(const auto& t : v_t) - { - IntervalVector z = cart_prod(t,y); - DefaultFigure::draw_box(z, Color::red()); - } .. figure:: inversion_example.png :width: 70% @@ -329,6 +220,60 @@ The following example computes the different connected components of the inversi :project: codac +Tube operations +--------------- + +Standard pointwise operations are available on sliced tubes and are applied slice by slice. + +For two tubes, binary operators require both operands to share the same :class:`~codac.TDomain`. This makes tube expressions easy to combine once the tubes have been built on a common temporal support. + +The following operators are available: + +* union and intersection: ``|`` and ``&``, +* arithmetic operations: ``+``, ``-``, ``*``, ``/``, +* in-place variants: ``|=``, ``&=``, ``+=``, ``-=``, ``*=``, ``/=``. + +For scalar interval tubes, several usual nonlinear functions are also provided, including ``sqr``, ``sqrt``, ``pow``, ``exp``, ``log``, ``sin``, ``cos``, ``tan``, ``atan2``, ``abs``, ``min``, ``max``, ``sign``, ``floor`` and ``ceil``. + +.. tabs:: + + .. group-tab:: Python + + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-6-beg] + :end-before: [slicedtube-class-6-end] + :dedent: 4 + + .. group-tab:: C++ + + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-6-beg] + :end-before: [slicedtube-class-6-end] + :dedent: 4 + +For vector-valued codomains, pointwise arithmetic is also available. In particular, the product of a matrix tube and a vector tube returns a vector tube. + +.. tabs:: + + .. group-tab:: Python + + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-7-beg] + :end-before: [slicedtube-class-7-end] + :dedent: 4 + + .. group-tab:: C++ + + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-7-beg] + :end-before: [slicedtube-class-7-end] + :dedent: 4 + + Integration and primitives -------------------------- @@ -339,7 +284,7 @@ Reliable integral computations are available on tubes. Hatched part depicts :math:`\int_{a}^{b}x^-(\tau)d\tau`, the lower bound of :math:`\int_{a}^{b}[x](\tau)d\tau`. -The computation is reliable because it stands on the tube's slices. The result is an outer approximation of the integral of the tube represented by these slices: +The computation is reliable even for tubes defined from analytic functions, because it stands on the tube's slices that are reliable enclosures. The result is an outer approximation of the integral of the tube represented by these slices: .. figure:: tube_lb_integral_slices.png :width: 70% @@ -357,32 +302,24 @@ Inflation, extraction, and algebraic helpers A sliced tube can be inflated either by a constant radius or by a time-varying sampled radius. Inflation is performed in place. - .. tabs:: .. group-tab:: Python - .. code-block:: py - - x.inflate(0.2) # constant inflation - - rad = SampledTraj() - rad.set(0.1, 0.0) - rad.set(0.3, 1.0) - rad.set(0.2, 2.0) - x.inflate(rad) # time-varying inflation radius + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-8-beg] + :end-before: [slicedtube-class-8-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-8-beg] + :end-before: [slicedtube-class-8-end] + :dedent: 4 - x.inflate(0.2); # constant inflation - - SampledTraj rad; - rad.set(0.1, 0.0); - rad.set(0.3, 1.0); - rad.set(0.2, 2.0); - x.inflate(rad); # time-varying inflation radius For vector-valued tubes, the API also provides convenient extraction operators: @@ -396,19 +333,19 @@ The extracted tubes keep the same temporal partition as the original one. .. group-tab:: Python - .. code-block:: py - - # Component and subvector extraction - x0 = x[0] - x12 = x.subvector(1,2) + .. literalinclude:: src.py + :language: py + :start-after: [slicedtube-class-9-beg] + :end-before: [slicedtube-class-9-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - // Component and subvector extraction - auto x0 = x[0]; // type: SlicedTube - auto x12 = x.subvector(1,2); // type: SlicedTube + .. literalinclude:: src.cpp + :language: c++ + :start-after: [slicedtube-class-9-beg] + :end-before: [slicedtube-class-9-end] + :dedent: 4 Involving a tube in an analytic expression diff --git a/doc/manual/manual/tubes/src.cpp b/doc/manual/manual/tubes/src.cpp new file mode 100644 index 000000000..38e32a0fd --- /dev/null +++ b/doc/manual/manual/tubes/src.cpp @@ -0,0 +1,248 @@ +/** + * Codac tests + * ---------------------------------------------------------------------------- + * \date 2026 + * \author Simon Rohou + * \copyright Copyright 2026 Codac Team + * \license GNU Lesser General Public License (LGPL) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace codac2; + +TEST_CASE("TDomain class - manual") +{ + { + // [tdomain-class-1-beg] + auto td0 = create_tdomain(); // one unbounded slice [-oo,oo] + auto td1 = create_tdomain({0,1}); // one slice [0,1] + auto td2 = create_tdomain({0,1}, 0.5, false); // [0,0.5],[0.5,1] + auto td3 = create_tdomain({0,1}, 0.5, true); // [0],[0,0.5],[0.5],[0.5,1],[1] + // [tdomain-class-1-end] + } + + { + // [tdomain-class-2-beg] + auto td = create_tdomain({0,1}, 0.5, true); // returns a std::shared_ptr + + Interval dom = td->t0_tf(); // [0,1] + size_t n = td->nb_tslices(); // 5 + size_t m = td->nb_tubes(); // 0 initially + + auto it = td->tslice(0.0); // [0] + it = td->tslice(0.1); // [0,0.5] + it = td->tslice(0.5); // [0.5] + it = td->tslice(0.6); // [0.5,1] + it = td->tslice(1.0); // [1] + // [tdomain-class-2-end] + CHECK(n == 5); + CHECK(m == 0); + CHECK(dom == Interval(0,1)); + } + + { + // [tdomain-class-3-beg] + auto td = create_tdomain(); // returns a std::shared_ptr + td->sample(1., false); // [-oo,1],[1,oo] + td->sample(10., true); // [-oo,1],[1,10],[10],[10,oo] + // [tdomain-class-3-end] + } + + { + // [tdomain-class-4-beg] + auto td = create_tdomain({0,2}, 1.0, false); // false: without gates + + SlicedTube x(td, Interval(0,1)); + SlicedTube v(td, Interval(-1,1)); + + cout << x << endl; // outputs [0,2]↦[0,1], 2 slices + cout << v << endl; // outputs [0,2]↦[0,1], 2 slices + + size_t n = td->nb_tslices(); // 2: [0,1],[1,2] + x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 + size_t m = td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices + cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + // [tdomain-class-4-end] + CHECK(n == 2); + CHECK(m == 4); + } + + { + // [tdomain-class-5-beg] + auto td = create_tdomain({0,3}, 1.0, false); + SlicedTube x(td, Interval(0,1)); + + cout << td->nb_tubes() << endl; // 1 + td->truncate({0.5,2.5}); + + cout << td->t0_tf() << endl; // [0.5,2.5] + cout << x << endl; // x now uses the truncated shared partition + // [tdomain-class-5-end] + } +} + +TEST_CASE("SlicedTube class - manual") +{ + Figure2D fig("Tube", GraphicOutput::VIBES); + fig.set_window_properties({50,50},{800,400}); + + { + // [slicedtube-class-1-beg] + auto td = create_tdomain({0,10}, 0.1, true); + + // Sliced tube from interval-type codomains + SlicedTube x(td, Interval(-1,1)); // x has type SlicedTube + SlicedTube y(td, IntervalVector(2)); // y has type SlicedTube + SlicedTube z(td, IntervalMatrix(2,2)); // z has type SlicedTube + + // Explicit template notation remains possible: + SlicedTube x2(td, Interval(-1,1)); + + // From an analytic function + ScalarVar t; + AnalyticFunction f({t}, sin(t)); + SlicedTube xf(td, f); + // xf has type SlicedTube because f outputs scalar values + + // From an analytic trajectory or sampled trajectory + AnalyticTraj at(AnalyticFunction({t},cos(t)), {0,10}); + SampledTraj st = AnalyticTraj(AnalyticFunction({t},cos(t)+t/10), {0,10}).sampled(1e-2); + auto xu = SlicedTube(td,at) | SlicedTube(td,st); // union (hull) of tubes + + fig.plot_tube(xf, {Color::dark_blue(),Color::light_gray()}); + fig.plot_tube(xu, {Color::dark_blue(),Color::light_gray()}); + // [slicedtube-class-1-end] + } + + { + // [slicedtube-class-2-beg] + auto td = create_tdomain({0,3}); + SlicedTube x(td, IntervalVector(2)); + x.set({{1,5},{-oo,2}}, {0,1}); + x.set({{2,8},{-oo,3}}, {1,2}); + x.set({{6,9},{-oo,4}}, {2,3}); + + auto s0 = x.first_slice(); + auto s1 = s0->next_slice(); + + for(const auto& s : x) + std::cout << s.t0_tf() << " -> " << s.codomain() << std::endl; + // [slicedtube-class-2-end] + } + + { + // [slicedtube-class-4-beg] + auto td = create_tdomain({0,3}, 1.0, false); + SlicedTube x(td, Interval()); + + x.set({1,5}, {0,1}); + x.set({2,8}, {1,2}); + x.set({6,9}, {2,3}); + + Interval y0 = x(0.5); // [1,5] + Interval y1 = x(1.5); // [2,8] + Interval y2 = x({0,3}); // [1,9] + Interval y3 = x(-1.0); // [-oo,oo] + + // No explicit gates: boundary values come from adjacent-slice intersections + Interval y4 = x(1.0); // [2,5] + Interval y5 = x(2.0); // [6,8] + Interval y6 = x(3.0); // [6,9] + // [slicedtube-class-4-end] + } + + { + Interval T(0,10); + auto td = create_tdomain(T, 1e-1); + + ScalarVar t; + + AnalyticTraj z1(AnalyticFunction({t},cos(t)), T); + AnalyticTraj z2(AnalyticFunction({t},cos(t)+t/10), T); + AnalyticTraj z3(AnalyticFunction({t},sin(t)+t/10), T); + SampledTraj z4 = AnalyticTraj(AnalyticFunction({t},sin(t)), T).sampled(1e-2); + + SlicedTube x1(td, z1); + SlicedTube x2(td, z2); + SlicedTube x3(td, z3); + SlicedTube x4(td, z4); + + auto x = x1 | x2 | x3 | x4; + + // [slicedtube-class-5-beg] + std::vector v_t; + Interval y(0,0.2); + x.invert(y, v_t); + + for(const auto& t : v_t) + { + IntervalVector z = cart_prod(t,y); + DefaultFigure::draw_box(z, Color::red()); + } + // [slicedtube-class-5-end] + } + + { + // [slicedtube-class-6-beg] + auto td = create_tdomain({0,2}, 1.0, false); + + SlicedTube x(td, Interval(1,2)); + SlicedTube y(td, Interval(-1,3)); + + auto z_add = x + y; // addition of two tubes + auto z_mul = 2. * x; // multiplication by a scalar/interval + auto z_hul = x | y; // hull (union) of two tubes + auto z_int = x & y; // intersection of two tubes + + auto u = sin(x) + exp(y); + // [slicedtube-class-6-end] + } + + { + auto td = create_tdomain(); + + // [slicedtube-class-7-beg] + SlicedTube A(td, IntervalMatrix(2,2)); + SlicedTube b(td, IntervalVector(2)); + + auto y = A * b; // type: SlicedTube + // [slicedtube-class-7-end] + } + + { + auto td = create_tdomain({0,2}); + SlicedTube x(td, Interval()); + + // [slicedtube-class-8-beg] + x.inflate(0.2); // constant inflation + + SampledTraj rad({{0.0,0.11}, {1.0,0.3}, {2.0,0.2}}); + x.inflate(rad); // time-varying inflation radius + // [slicedtube-class-8-end] + } + + { + auto td = create_tdomain(); + SlicedTube x(td, IntervalVector(3)); + + // [slicedtube-class-9-beg] + // Component and subvector extraction + auto x0 = x[0]; // type: SlicedTube + auto x12 = x.subvector(1,2); // type: SlicedTube + // [slicedtube-class-9-end] + } + +} \ No newline at end of file diff --git a/doc/manual/manual/tubes/src.py b/doc/manual/manual/tubes/src.py new file mode 100644 index 000000000..f28be9598 --- /dev/null +++ b/doc/manual/manual/tubes/src.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python + +# Codac tests +# ---------------------------------------------------------------------------- +# \date 2026 +# \author Simon Rohou +# \copyright Copyright 2026 Codac Team +# \license GNU Lesser General Public License (LGPL) + +import sys, os +import unittest +import math +from codac import * + +class TestTubeManual(unittest.TestCase): + + def tests_TDomain_manual(test): + + # [tdomain-class-1-beg] + td0 = create_tdomain() # one unbounded slice [-oo,oo] + td1 = create_tdomain([0,1]) # one slice [0,1] + td2 = create_tdomain([0,1], 0.5, False) # [0,0.5],[0.5,1] + td3 = create_tdomain([0,1], 0.5, True) # [0],[0,0.5],[0.5],[0.5,1],[1] + # [tdomain-class-1-end] + + # [tdomain-class-2-beg] + td = create_tdomain([0,1], 0.5, True) + + dom = td.t0_tf() # [0,1] + n = td.nb_tslices() # 5 + m = td.nb_tubes() # 0 initially + + td.tslice(0.0) # [0] + td.tslice(0.1) # [0,0.5] + td.tslice(0.5) # [0.5] + td.tslice(0.6) # [0.5,1] + td.tslice(1.0) # [1] + # [tdomain-class-2-end] + + test.assertTrue(n == 5) + test.assertTrue(m == 0) + test.assertTrue(dom == Interval(0,1)) + + # [tdomain-class-3-beg] + td = create_tdomain() + td.sample(1.0, False) # [-oo,1],[1,oo] + td.sample(10.0, True) # [-oo,1],[1,10],[10],[10,oo] + # [tdomain-class-3-end] + + # [tdomain-class-4-beg] + td = create_tdomain([0,2], 1.0, False) # False: without gates + + x = SlicedTube(td, Interval(0,1)) + v = SlicedTube(td, Interval(-1,1)) + + print(x) # outputs [0,2]↦[0,1], 2 slices + print(v) # outputs [0,2]↦[0,1], 2 slices + + n = td.nb_tslices() # 2: [0,1],[1,2] + x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 + m = td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] + + print(x) # outputs [0,2]↦[-1,1], 4 slices + print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + # [tdomain-class-4-end] + + test.assertTrue(n == 2) + test.assertTrue(m == 4) + + # [tdomain-class-5-beg] + td = create_tdomain([0,3], 1.0, False) + x = SlicedTube(td, Interval(0,1)) + + td.nb_tubes() # 1 + td.truncate([0.5,2.5]) + + print(td.t0_tf()) # [0.5,2.5] + print(x) # x now uses the truncated shared partition + # [tdomain-class-5-end] + + + def tests_SlicedTube_manual(test): + + fig = Figure2D("Tube", GraphicOutput.VIBES) + fig.set_window_properties([50,50],[800,400]) + + # [slicedtube-class-1-beg] + td = create_tdomain([0,10], 0.1, True) + + # Sliced tube from interval-type codomains + x = SlicedTube(td, Interval(-1,1)) + y = SlicedTube(td, IntervalVector(2)) + z = SlicedTube(td, IntervalMatrix(2,2)) + + # From an analytic function + t = ScalarVar() + f = AnalyticFunction([t], sin(t)) + xf = SlicedTube(td, f) + + # From an analytic trajectory or sampled trajectory + at = AnalyticTraj(AnalyticFunction([t],cos(t)), [0,10]) + st = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), [0,10]).sampled(1e-2) + xu = SlicedTube(td,at) | SlicedTube(td,st) # union (hull) of tubes + + fig.plot_tube(xf, [Color.dark_blue(),Color.light_gray()]) + fig.plot_tube(xu, [Color.dark_blue(),Color.light_gray()]) + # [slicedtube-class-1-end] + + # [slicedtube-class-2-beg] + td = create_tdomain([0,3]) + x = SlicedTube(td, IntervalVector(2)) + x.set([[1,5],[-oo,2]], [0,1]) + x.set([[2,8],[-oo,3]], [1,2]) + x.set([[6,9],[-oo,4]], [2,3]) + + s0 = x.first_slice() + s1 = s0.next_slice() + + for s in x: + print(s.t0_tf(), s.codomain()) + # [slicedtube-class-2-end] + + # [slicedtube-class-4-beg] + td = create_tdomain([0,3], 1.0, False) + x = SlicedTube(td, Interval()) + + x.set([1,5], [0,1]) + x.set([2,8], [1,2]) + x.set([6,9], [2,3]) + + x(0.5) # [1,5] + x(1.5) # [2,8] + x([0,3]) # [1,9] + x(-1.0) # [-oo,oo] + + # No explicit gates: boundary values come from adjacent-slice intersections + x(1.0) # [2,5] + x(2.0) # [6,8] + x(3.0) # [6,9] + # [slicedtube-class-4-end] + + T = Interval(0,10) + td = create_tdomain(T, 1e-1) + + t = ScalarVar() + + z1 = AnalyticTraj(AnalyticFunction([t],cos(t)), T) + z2 = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), T) + z3 = AnalyticTraj(AnalyticFunction([t],sin(t)+t/10), T) + z4 = AnalyticTraj(AnalyticFunction([t],sin(t)), T).sampled(1e-2) + + x1 = SlicedTube(td, z1) + x2 = SlicedTube(td, z2) + x3 = SlicedTube(td, z3) + x4 = SlicedTube(td, z4) + + x = x1 | x2 | x3 | x4 + + # [slicedtube-class-5-beg] + v_t = [] + y = Interval(0,0.2) + x.invert(y,v_t) + + for t in v_t: + z = cart_prod(t,y) + DefaultFigure.draw_box(z, Color.red()) + # [slicedtube-class-5-end] + + # [slicedtube-class-6-beg] + td = create_tdomain([0,2], 1.0, False) + + x = SlicedTube(td, Interval(1,2)) + y = SlicedTube(td, Interval(-1,3)) + + z_add = x + y # addition of two tubes + z_mul = 2 * x # multiplication by a scalar/interval + z_hul = x | y # hull (union) of two tubes + z_int = x & y # intersection of two tubes + + u = sin(x) + exp(y) + # [slicedtube-class-6-end] + + # [slicedtube-class-7-beg] + A = SlicedTube(td, IntervalMatrix(2,2)) + b = SlicedTube(td, IntervalVector(2)) + + y = A * b + # [slicedtube-class-7-end] + + td = create_tdomain([0,2]) + x = SlicedTube(td, Interval()) + + # [slicedtube-class-8-beg] + x.inflate(0.2) # constant inflation + + rad = SampledTraj({0.0:0.1, 1.0:0.3, 2.0:0.2}) + x.inflate(rad) # time-varying inflation radius + # [slicedtube-class-8-end] + + td = create_tdomain() + x = SlicedTube(td, IntervalVector(3)) + + # [slicedtube-class-9-beg] + # Component and subvector extraction + x0 = x[0] + x12 = x.subvector(1,2) + # [slicedtube-class-9-end] + + pass + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/doc/manual/manual/tubes/tdomain.rst b/doc/manual/manual/tubes/tdomain.rst index e02765956..d65eebdc4 100644 --- a/doc/manual/manual/tubes/tdomain.rst +++ b/doc/manual/manual/tubes/tdomain.rst @@ -1,4 +1,4 @@ -.. _sec-domains-tdomain: +.. _sec-domains-tubes-tdomain: The TDomain class ================= @@ -32,21 +32,20 @@ The following examples show the expected structures for the sampled cases above, .. group-tab:: Python - .. code-block:: py - - td0 = create_tdomain() # one unbounded slice [-oo,oo] - td1 = create_tdomain([0,1]) # one slice [0,1] - td2 = create_tdomain([0,1], 0.5, False) # [0,0.5],[0.5,1] - td3 = create_tdomain([0,1], 0.5, True) # [0],[0,0.5],[0.5],[0.5,1],[1] + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-1-beg] + :end-before: [tdomain-class-1-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-1-beg] + :end-before: [tdomain-class-1-end] + :dedent: 4 - auto td0 = create_tdomain(); // one unbounded slice [-oo,oo] - auto td1 = create_tdomain({0,1}); // one slice [0,1] - auto td2 = create_tdomain({0,1}, 0.5, false); // [0,0.5],[0.5,1] - auto td3 = create_tdomain({0,1}, 0.5, true); // [0],[0,0.5],[0.5],[0.5,1],[1] Inspecting the partition ------------------------ @@ -63,35 +62,19 @@ A temporal domain exposes: .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,1], 0.5, True) - - td.t0_tf() # [0,1] - td.nb_tslices() # 5 - td.nb_tubes() # 0 initially - - td.tslice(0.0) # [0] - td.tslice(0.1) # [0,0.5] - td.tslice(0.5) # [0.5] - td.tslice(0.6) # [0.5,1] - td.tslice(1.0) # [1] + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-2-beg] + :end-before: [tdomain-class-2-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,1}, 0.5, true); // returns a std::shared_ptr - - Interval dom = td->t0_tf(); // [0,1] - size_t n = td->nb_tslices(); // 5 - size_t m = td->nb_tubes(); // 0 initially - - auto it = td->tslice(0.0); // [0] - auto it = td->tslice(0.1); // [0,0.5] - auto it = td->tslice(0.5); // [0.5] - auto it = td->tslice(0.6); // [0.5,1] - auto it = td->tslice(1.0); // [1] + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-2-beg] + :end-before: [tdomain-class-2-end] + :dedent: 4 Note that ``tslice(t)`` returns the gate when ``t`` matches an explicit gate, and @@ -115,19 +98,19 @@ Sampling can occur: .. group-tab:: Python - .. code-block:: py - - td = create_tdomain() - td.sample(1.0, False) # [-oo,1][1,oo] - td.sample(10.0, True) # [-oo,1],[1,10],[10],[10,oo] + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-3-beg] + :end-before: [tdomain-class-3-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain(); // returns a std::shared_ptr - td->sample(1., false); // [-oo,1],[1,oo] - td->sample(10., true); // [-oo,1],[1,10],[10],[10,oo] + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-3-beg] + :end-before: [tdomain-class-3-end] + :dedent: 4 One important implementation detail is that refinement preserves the attached tubes by cloning the corresponding slice objects onto the new temporal elements. The new slices are then reattached to @@ -145,41 +128,19 @@ The following code illustrates this effect: .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,2], 1.0, False) # False: without gates - - x = SlicedTube(td, Interval(0,1)) - v = SlicedTube(td, Interval(-1,1)) - - print(x) # outputs [0,2]↦[0,1], 2 slices - print(v) # outputs [0,2]↦[0,1], 2 slices - - td.nb_tslices() # 2: [0,1],[1,2] - x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 - td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] - - print(x) # outputs [0,2]↦[-1,1], 4 slices - print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-4-beg] + :end-before: [tdomain-class-4-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,2}, 1.0, false); // false: without gates - - SlicedTube x(td, Interval(0,1)); - SlicedTube v(td, Interval(-1,1)); - - cout << x << endl; // outputs [0,2]↦[0,1], 2 slices - cout << v << endl; // outputs [0,2]↦[0,1], 2 slices - - td->nb_tslices(); // 2: [0,1],[1,2] - x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 - td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] - - cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices - cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-4-beg] + :end-before: [tdomain-class-4-end] + :dedent: 4 .. note:: @@ -213,26 +174,16 @@ attached tubes, and the number of attached tubes can be queried with .. group-tab:: Python - .. code-block:: py - - td = create_tdomain([0,3], 1.0, False) - x = SlicedTube(td, Interval(0,1)) - - td.nb_tubes() # 1 - td.truncate([0.5,2.5]) - - print(td.t0_tf()) # [0.5,2.5] - print(x) # x now uses the truncated shared partition + .. literalinclude:: src.py + :language: py + :start-after: [tdomain-class-5-beg] + :end-before: [tdomain-class-5-end] + :dedent: 4 .. group-tab:: C++ - .. code-block:: c++ - - auto td = create_tdomain({0,3}, 1.0, false); - SlicedTube x(td, Interval(0,1)); - - std::cout << td->nb_tubes() << std::endl; // 1 - td->truncate({0.5,2.5}); - - std::cout << td->t0_tf() << std::endl; // [0.5,2.5] - std::cout << x << std::endl; // x now uses the truncated shared partition \ No newline at end of file + .. literalinclude:: src.cpp + :language: c++ + :start-after: [tdomain-class-5-beg] + :end-before: [tdomain-class-5-end] + :dedent: 4 \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c9ef12a5b..c38934659 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -53,6 +53,7 @@ list(APPEND SRC_TESTS # listing files without extension core/domains/interval/codac2_tests_Interval_operations core/domains/interval/codac2_tests_IntervalMatrix core/domains/interval/codac2_tests_IntervalVector + ../doc/manual/manual/intervals/src core/domains/zonotope/codac2_tests_Parallelepiped core/domains/zonotope/codac2_tests_Parallelepiped_eval core/domains/tube/codac2_tests_TDomain @@ -60,7 +61,7 @@ list(APPEND SRC_TESTS # listing files without extension core/domains/tube/codac2_tests_Slice_polygon core/domains/tube/codac2_tests_SlicedTube core/domains/tube/codac2_tests_SlicedTube_integral - ../doc/manual/manual/intervals/src + ../doc/manual/manual/tubes/src core/functions/analytic/codac2_tests_AnalyticFunction ../doc/manual/manual/functions/analytic/src From 0ddc327e1f47a668a8c1736c799a86b2da225834 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 16:32:06 +0200 Subject: [PATCH 15/21] [py] corrected compilation error on Windows actions --- python/src/codac2_py_matlab.h | 6 +++--- .../core/domains/interval/codac2_py_IntervalMatrixBase.h | 2 +- .../Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/python/src/codac2_py_matlab.h b/python/src/codac2_py_matlab.h index 4eb477b53..b128d2001 100644 --- a/python/src/codac2_py_matlab.h +++ b/python/src/codac2_py_matlab.h @@ -57,15 +57,15 @@ namespace codac2 return x; } - inline auto convert_indices(const std::vector& indices) + inline std::vector convert_indices(const std::vector& indices) { if constexpr(FOR_MATLAB) { - std::vector indices_(indices.size()); + std::vector indices_(indices.size()); for(size_t i = 0 ; i < indices.size() ; i++) { matlab::test_integer(indices[i]); - indices_[i] = (Index_type)matlab::input_index(indices[i]); + indices_[i] = (Index)matlab::input_index(indices[i]); } return indices_; diff --git a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h index b31f9d7f5..84059ee33 100644 --- a/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h +++ b/python/src/core/domains/interval/codac2_py_IntervalMatrixBase.h @@ -199,7 +199,7 @@ void export_IntervalMatrixBase(py::module& m, py::class_& pyclass) return x.bisect_largest(ratio, among_indices.empty() ? among_indices : matlab::convert_indices(among_indices)); }, - MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_LARGEST_FLOAT_CONST_VECTOR_INDEX_REF_CONST, + MATRIX_ADDONS_INTERVALMATRIXBASE_AUTO_BISECT_LARGEST_DOUBLE_CONST_VECTOR_INDEX_REF_CONST, "ratio"_a = 0.49, "among_indices"_a=std::vector()) ; diff --git a/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h b/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h index fea1964d0..64ef607a3 100644 --- a/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h +++ b/src/core/matrices/eigen/Matrix_addons/codac2_Matrix_addons_IntervalMatrixBase.h @@ -339,7 +339,7 @@ inline auto bisect(Index i, float ratio = 0.49) const */ template requires IsIntervalDomain -inline auto bisect_largest(float ratio = 0.49, const std::vector& among_indices = {}) const +inline auto bisect_largest(double ratio = 0.49, const std::vector& among_indices = {}) const { return bisect(this->max_diam_index(among_indices), ratio); } \ No newline at end of file From 51649b10c00a8c6c654ff443e9830193222df1e1 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 16:33:09 +0200 Subject: [PATCH 16/21] [traj] AnalyticTraj: permutting constructor arguments --- doc/manual/manual/tubes/src.cpp | 12 ++++++------ doc/manual/manual/tubes/src.py | 12 ++++++------ examples/00_graphics/graphic_examples.cpp | 2 +- examples/00_graphics/graphic_examples.m | 2 +- examples/00_graphics/graphic_examples.py | 2 +- examples/04_explored_area/main.cpp | 4 ++-- examples/04_explored_area/main.py | 4 ++-- examples/07_centered_2D/main.cpp | 2 +- python/codac/core/__init__.py | 17 +++++++++++++---- .../core/trajectory/codac2_py_AnalyticTraj.cpp | 6 +++--- src/core/trajectory/codac2_AnalyticTraj.h | 2 +- .../domains/tube/codac2_tests_SlicedTube.cpp | 4 ++-- .../domains/tube/codac2_tests_SlicedTube.py | 4 ++-- .../core/tools/codac2_tests_transformations.cpp | 4 ++-- .../core/tools/codac2_tests_transformations.py | 4 ++-- .../trajectory/codac2_tests_AnalyticTraj.cpp | 2 +- .../trajectory/codac2_tests_AnalyticTraj.py | 2 +- .../trajectory/codac2_tests_SampledTraj.cpp | 10 +++++----- .../core/trajectory/codac2_tests_SampledTraj.py | 8 ++++---- 19 files changed, 56 insertions(+), 47 deletions(-) diff --git a/doc/manual/manual/tubes/src.cpp b/doc/manual/manual/tubes/src.cpp index 38e32a0fd..ee1c42e2b 100644 --- a/doc/manual/manual/tubes/src.cpp +++ b/doc/manual/manual/tubes/src.cpp @@ -118,8 +118,8 @@ TEST_CASE("SlicedTube class - manual") // xf has type SlicedTube because f outputs scalar values // From an analytic trajectory or sampled trajectory - AnalyticTraj at(AnalyticFunction({t},cos(t)), {0,10}); - SampledTraj st = AnalyticTraj(AnalyticFunction({t},cos(t)+t/10), {0,10}).sampled(1e-2); + AnalyticTraj at({0,10}, AnalyticFunction({t},cos(t))); + SampledTraj st = AnalyticTraj({0,10}, AnalyticFunction({t},cos(t)+t/10)).sampled(1e-2); auto xu = SlicedTube(td,at) | SlicedTube(td,st); // union (hull) of tubes fig.plot_tube(xf, {Color::dark_blue(),Color::light_gray()}); @@ -170,10 +170,10 @@ TEST_CASE("SlicedTube class - manual") ScalarVar t; - AnalyticTraj z1(AnalyticFunction({t},cos(t)), T); - AnalyticTraj z2(AnalyticFunction({t},cos(t)+t/10), T); - AnalyticTraj z3(AnalyticFunction({t},sin(t)+t/10), T); - SampledTraj z4 = AnalyticTraj(AnalyticFunction({t},sin(t)), T).sampled(1e-2); + AnalyticTraj z1(T, AnalyticFunction({t},cos(t))); + AnalyticTraj z2(T, AnalyticFunction({t},cos(t)+t/10)); + AnalyticTraj z3(T, AnalyticFunction({t},sin(t)+t/10)); + SampledTraj z4 = AnalyticTraj(T, AnalyticFunction({t},sin(t))).sampled(1e-2); SlicedTube x1(td, z1); SlicedTube x2(td, z2); diff --git a/doc/manual/manual/tubes/src.py b/doc/manual/manual/tubes/src.py index f28be9598..00e939c3c 100644 --- a/doc/manual/manual/tubes/src.py +++ b/doc/manual/manual/tubes/src.py @@ -98,8 +98,8 @@ def tests_SlicedTube_manual(test): xf = SlicedTube(td, f) # From an analytic trajectory or sampled trajectory - at = AnalyticTraj(AnalyticFunction([t],cos(t)), [0,10]) - st = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), [0,10]).sampled(1e-2) + at = AnalyticTraj([0,10], AnalyticFunction([t],cos(t))) + st = AnalyticTraj([0,10], AnalyticFunction([t],cos(t)+t/10)).sampled(1e-2) xu = SlicedTube(td,at) | SlicedTube(td,st) # union (hull) of tubes fig.plot_tube(xf, [Color.dark_blue(),Color.light_gray()]) @@ -144,10 +144,10 @@ def tests_SlicedTube_manual(test): t = ScalarVar() - z1 = AnalyticTraj(AnalyticFunction([t],cos(t)), T) - z2 = AnalyticTraj(AnalyticFunction([t],cos(t)+t/10), T) - z3 = AnalyticTraj(AnalyticFunction([t],sin(t)+t/10), T) - z4 = AnalyticTraj(AnalyticFunction([t],sin(t)), T).sampled(1e-2) + z1 = AnalyticTraj(T, AnalyticFunction([t],cos(t))) + z2 = AnalyticTraj(T, AnalyticFunction([t],cos(t)+t/10)) + z3 = AnalyticTraj(T, AnalyticFunction([t],sin(t)+t/10)) + z4 = AnalyticTraj(T, AnalyticFunction([t],sin(t))).sampled(1e-2) x1 = SlicedTube(td, z1) x2 = SlicedTube(td, z2) diff --git a/examples/00_graphics/graphic_examples.cpp b/examples/00_graphics/graphic_examples.cpp index 7c4fe8b07..90e7cd040 100644 --- a/examples/00_graphics/graphic_examples.cpp +++ b/examples/00_graphics/graphic_examples.cpp @@ -119,6 +119,6 @@ int main(){ ScalarVar t; // Fermat's spiral AnalyticFunction f1 ({t},{a*sqrt(t)*cos(t),a*sqrt(t)*sin(t)}); - AnalyticTraj traj4 (f1,{0,100}); + AnalyticTraj traj4 ({0,100},f1); fig4.draw_trajectory(traj4,{ColorMap::rainbow(), ".."}); } diff --git a/examples/00_graphics/graphic_examples.m b/examples/00_graphics/graphic_examples.m index 2190ec6fe..a8463267e 100644 --- a/examples/00_graphics/graphic_examples.m +++ b/examples/00_graphics/graphic_examples.m @@ -108,5 +108,5 @@ t = ScalarVar(); % Fermat's spiral f1 = AnalyticFunction({t},vec(a*sqrt(t)*cos(t),a*sqrt(t)*sin(t))); -traj4 = AnalyticTraj(f1,Interval(0,100)); +traj4 = AnalyticTraj(Interval(0,100),f1); fig4.draw_trajectory(traj4, StyleGradientProperties(ColorMap().rainbow(), "..")); \ No newline at end of file diff --git a/examples/00_graphics/graphic_examples.py b/examples/00_graphics/graphic_examples.py index 54a790913..060138e88 100644 --- a/examples/00_graphics/graphic_examples.py +++ b/examples/00_graphics/graphic_examples.py @@ -111,5 +111,5 @@ t=ScalarVar() # Fermat's spiral f1=AnalyticFunction([t], [a*sqrt(t)*cos(t),a*sqrt(t)*sin(t)]) -traj4=AnalyticTraj(f1, [0,100]) +traj4=AnalyticTraj([0,100],f1) fig4.draw_trajectory(traj4, StyleGradientProperties(ColorMap.rainbow(),"..")) \ No newline at end of file diff --git a/examples/04_explored_area/main.cpp b/examples/04_explored_area/main.cpp index 649c4690b..e1d646348 100644 --- a/examples/04_explored_area/main.cpp +++ b/examples/04_explored_area/main.cpp @@ -18,7 +18,7 @@ int main() }; Interval tdomain(0,5); - auto sampled_f = AnalyticTraj(f,tdomain).sampled(0.8); + auto sampled_f = AnalyticTraj(tdomain,f).sampled(0.8); sampled_f.set({0,-1}, 6.); // appending the position (0,-1) at t=6 VectorVar w(3); @@ -33,5 +33,5 @@ int main() DefaultFigure::pave({{-3,3},{-2,2}}, s_projh, 5e-2); DefaultFigure::draw_trajectory(sampled_f); - DefaultFigure::draw_trajectory(AnalyticTraj(f,tdomain), Color::dark_gray()); + DefaultFigure::draw_trajectory(AnalyticTraj(tdomain,f), Color::dark_gray()); } \ No newline at end of file diff --git a/examples/04_explored_area/main.py b/examples/04_explored_area/main.py index 2990a5022..2e6046b49 100644 --- a/examples/04_explored_area/main.py +++ b/examples/04_explored_area/main.py @@ -14,7 +14,7 @@ ) tdomain = [0,5] -sampled_f = AnalyticTraj(f,tdomain).sampled(0.8) +sampled_f = AnalyticTraj(tdomain,f).sampled(0.8) sampled_f.set([0,-1], 6.) # appending the position (0,-1) at t=6 w = VectorVar(3) @@ -29,4 +29,4 @@ DefaultFigure.pave([[-3,3],[-2,2]], s_projh, 5e-2) DefaultFigure.draw_trajectory(sampled_f) -DefaultFigure.draw_trajectory(AnalyticTraj(f,tdomain), Color.dark_gray()) \ No newline at end of file +DefaultFigure.draw_trajectory(AnalyticTraj(tdomain,f), Color.dark_gray()) \ No newline at end of file diff --git a/examples/07_centered_2D/main.cpp b/examples/07_centered_2D/main.cpp index 48ca64520..bfc069633 100644 --- a/examples/07_centered_2D/main.cpp +++ b/examples/07_centered_2D/main.cpp @@ -43,6 +43,6 @@ int main(){ time = time+dt; } - AnalyticTraj traj4 (f1,{0,100}); + AnalyticTraj traj4 ({0,100},f1); fig4.draw_trajectory(traj4,Color::black()); } diff --git a/python/codac/core/__init__.py b/python/codac/core/__init__.py index 45f43fff0..831311cc6 100644 --- a/python/codac/core/__init__.py +++ b/python/codac/core/__init__.py @@ -370,17 +370,26 @@ def SampledTraj(x=None, y=None): return cls({float(t): cast(v) for t, v in zip(x, y)}) -def AnalyticTraj(f, t): +def AnalyticTraj(t,f): + + if isinstance(t, _ANALYTIC_FUNCTION_TYPES) and not isinstance(f, _ANALYTIC_FUNCTION_TYPES): + warnings.warn( + "AnalyticTraj(f,t) is deprecated; use AnalyticTraj(t,f) instead.", + FutureWarning, + stacklevel=2 + ) + t,f = f,t + f = AnalyticFunction(f) if isinstance(f, AnalyticFunction_Scalar): - return AnalyticTraj_Scalar(f, t) + return AnalyticTraj_Scalar(t,f) if isinstance(f, AnalyticFunction_Vector): - return AnalyticTraj_Vector(f, t) + return AnalyticTraj_Vector(t,f) if isinstance(f, AnalyticFunction_Matrix): - return AnalyticTraj_Matrix(f, t) + return AnalyticTraj_Matrix(t,f) codac_error("AnalyticTraj: can only build this trajectory from an AnalyticFunction_[Scalar/Vector/Matrix]") diff --git a/python/src/core/trajectory/codac2_py_AnalyticTraj.cpp b/python/src/core/trajectory/codac2_py_AnalyticTraj.cpp index 0a2f2b06e..6d5dce31d 100644 --- a/python/src/core/trajectory/codac2_py_AnalyticTraj.cpp +++ b/python/src/core/trajectory/codac2_py_AnalyticTraj.cpp @@ -32,9 +32,9 @@ void _export_AnalyticTraj(py::module& m, const string& class_name) exported_class - .def(py::init&,const Interval&>(), - ANALYTICTRAJ_T_ANALYTICTRAJ_CONST_ANALYTICFUNCTION_T_REF_CONST_INTERVAL_REF, - "f"_a, "tdomain"_a) + .def(py::init&>(), + ANALYTICTRAJ_T_ANALYTICTRAJ_CONST_INTERVAL_REF_CONST_ANALYTICFUNCTION_T_REF, + "tdomain"_a, "f"_a) .def("__call__", (typename T::Scalar (AnalyticTraj::*) (double) const) &AnalyticTraj::operator(), VIRTUAL_T_SCALAR_ANALYTICTRAJ_T_OPERATORCALL_DOUBLE_CONST, diff --git a/src/core/trajectory/codac2_AnalyticTraj.h b/src/core/trajectory/codac2_AnalyticTraj.h index eb98e4a25..8c5cf51cd 100644 --- a/src/core/trajectory/codac2_AnalyticTraj.h +++ b/src/core/trajectory/codac2_AnalyticTraj.h @@ -22,7 +22,7 @@ namespace codac2 using Type = T; - AnalyticTraj(const AnalyticFunction& f, const Interval& tdomain) + AnalyticTraj(const Interval& tdomain, const AnalyticFunction& f) : TrajBase(), AnalyticFunction(f), _tdomain(tdomain) { assert_release(f.args().total_size() == 1 && "domain of f must be 1d"); diff --git a/tests/core/domains/tube/codac2_tests_SlicedTube.cpp b/tests/core/domains/tube/codac2_tests_SlicedTube.cpp index 9d42d3ef7..686e4a670 100644 --- a/tests/core/domains/tube/codac2_tests_SlicedTube.cpp +++ b/tests/core/domains/tube/codac2_tests_SlicedTube.cpp @@ -417,7 +417,7 @@ TEST_CASE("SlicedTube") { ScalarVar t; AnalyticFunction f { {t}, cos(t) }; - AnalyticTraj analytic_traj(f, {-PI,PI}); + AnalyticTraj analytic_traj({-PI,PI},f); auto sampled_traj = analytic_traj.sampled(1e-2); auto tdomain = create_tdomain({-PI,PI},1e-2,false); SlicedTube tube(tdomain, sampled_traj); @@ -437,7 +437,7 @@ TEST_CASE("SlicedTube") vec(2*cos(t),sin(2*t)) }; - auto analytic_traj = AnalyticTraj(f, {0,5}); + auto analytic_traj = AnalyticTraj({0,5},f); auto sampled_traj = analytic_traj.sampled(1e-2); auto tdomain = create_tdomain({0,5},1e-3,false); SlicedTube tube(tdomain, sampled_traj); diff --git a/tests/core/domains/tube/codac2_tests_SlicedTube.py b/tests/core/domains/tube/codac2_tests_SlicedTube.py index 9d7766e34..8b0e39a51 100644 --- a/tests/core/domains/tube/codac2_tests_SlicedTube.py +++ b/tests/core/domains/tube/codac2_tests_SlicedTube.py @@ -321,7 +321,7 @@ def test_SlicedTube_as_operator_1dcase(self): t = ScalarVar() f = AnalyticFunction([t], cos(t)) - analytic_traj = AnalyticTraj(f, [-PI,PI]) + analytic_traj = AnalyticTraj([-PI,PI],f) sampled_traj = analytic_traj.sampled(1e-2) tdomain = create_tdomain([-PI,PI],1e-2,False) tube = SlicedTube(tdomain, sampled_traj) @@ -342,7 +342,7 @@ def test_SlicedTube_as_operator_ndcase(self): vec(2*cos(t),sin(2*t)) ) - analytic_traj = AnalyticTraj(f, [0,5]) + analytic_traj = AnalyticTraj([0,5],f) sampled_traj = analytic_traj.sampled(1e-2) tdomain = create_tdomain([0,5],1e-3,False) tube = SlicedTube(tdomain, sampled_traj) diff --git a/tests/core/tools/codac2_tests_transformations.cpp b/tests/core/tools/codac2_tests_transformations.cpp index 9a182c0f4..ba4ed42bb 100644 --- a/tests/core/tools/codac2_tests_transformations.cpp +++ b/tests/core/tools/codac2_tests_transformations.cpp @@ -27,7 +27,7 @@ TEST_CASE("Affine transformation") 2*sin(t)+0.1*sin(10*t) }); - SampledTraj src = AnalyticTraj(f_src,{-1,3}).sampled(0.01); + SampledTraj src = AnalyticTraj({-1,3},f_src).sampled(0.01); // The dst trajectory is obtained analytically with a // transformation described by the parameters: @@ -43,7 +43,7 @@ TEST_CASE("Affine transformation") b*sin(a)*f_src(t)[0]+b*cos(a)*f_src(t)[1] + T[1] + 0.05*sin(100*t) }); - SampledTraj dst = AnalyticTraj(f_dst,{-1,3}).sampled(0.01); + SampledTraj dst = AnalyticTraj({-1,3},f_dst).sampled(0.01); //DefaultFigure::set_window_properties({75,75},{700,700}); //DefaultFigure::set_axes(axis(0,{-8,4}), axis(1,{-4,8})); diff --git a/tests/core/tools/codac2_tests_transformations.py b/tests/core/tools/codac2_tests_transformations.py index 2a1caeb43..6344e1625 100644 --- a/tests/core/tools/codac2_tests_transformations.py +++ b/tests/core/tools/codac2_tests_transformations.py @@ -23,7 +23,7 @@ def test_affine_transformation(self): 2*sin(t)+0.1*sin(10*t) ]) - src = AnalyticTraj(f_src,[-1,3]).sampled(0.01) + src = AnalyticTraj([-1,3],f_src).sampled(0.01) # The dst trajectory is obtained analytically with a # transformation described by the parameters: @@ -36,7 +36,7 @@ def test_affine_transformation(self): b*sin(a)*f_src(t)[0]+b*cos(a)*f_src(t)[1] + T[1] + 0.05*sin(100*t) ]) - dst = AnalyticTraj(f_dst,[-1,3]).sampled(0.01) + dst = AnalyticTraj([-1,3],f_dst).sampled(0.01) # Computing the transformation diff --git a/tests/core/trajectory/codac2_tests_AnalyticTraj.cpp b/tests/core/trajectory/codac2_tests_AnalyticTraj.cpp index ff91cb916..cd85b01bd 100644 --- a/tests/core/trajectory/codac2_tests_AnalyticTraj.cpp +++ b/tests/core/trajectory/codac2_tests_AnalyticTraj.cpp @@ -28,7 +28,7 @@ TEST_CASE("AnalyticTraj") sqr(t) }; - AnalyticTraj traj(f, {-1,10}); + AnalyticTraj traj({-1,10},f); CHECK(traj.tdomain() == Interval(-1,10)); CHECK(traj.codomain() == Interval(0,100)); diff --git a/tests/core/trajectory/codac2_tests_AnalyticTraj.py b/tests/core/trajectory/codac2_tests_AnalyticTraj.py index 99eccdcff..664d37e2e 100644 --- a/tests/core/trajectory/codac2_tests_AnalyticTraj.py +++ b/tests/core/trajectory/codac2_tests_AnalyticTraj.py @@ -25,7 +25,7 @@ def test_AnalyticTraj(self): sqr(t) ) - traj = AnalyticTraj(f, [-1,10]) + traj = AnalyticTraj([-1,10],f) self.assertTrue(traj.tdomain() == Interval(-1,10)) self.assertTrue(traj.codomain() == Interval(0,100)) diff --git a/tests/core/trajectory/codac2_tests_SampledTraj.cpp b/tests/core/trajectory/codac2_tests_SampledTraj.cpp index 7da03d89a..4addc7c93 100644 --- a/tests/core/trajectory/codac2_tests_SampledTraj.cpp +++ b/tests/core/trajectory/codac2_tests_SampledTraj.cpp @@ -68,7 +68,7 @@ TEST_CASE("SampledTraj as operator (1d case)") { ScalarVar t; AnalyticFunction f { {t}, cos(t) }; - AnalyticTraj analytic_traj(f, {-PI,PI}); + AnalyticTraj analytic_traj({-PI,PI},f); auto sampled_traj = analytic_traj.sampled(1e-2); auto g = sampled_traj.as_function(); @@ -86,7 +86,7 @@ TEST_CASE("SampledTraj as operator (nd case)") vec(2*cos(t),sin(2*t)) }; - auto analytic_traj = AnalyticTraj(f, {0,5}); + auto analytic_traj = AnalyticTraj({0,5},f); auto sampled_traj = analytic_traj.sampled(1e-2); auto g = sampled_traj.as_function(); @@ -114,7 +114,7 @@ TEST_CASE("SampledTraj: operations") { ScalarVar t; AnalyticFunction h { {t}, t }; - auto analytic_traj = AnalyticTraj(h, {-PI,PI}); + auto analytic_traj = AnalyticTraj({-PI,PI},h); SampledTraj x = analytic_traj.sampled(1e-2); CHECK(Approx(cos(x).codomain(),1e-5) == Interval(-1,1)); x = cos(x) + 4.; @@ -136,8 +136,8 @@ TEST_CASE("SampledTraj: derivative") { ScalarVar t; AnalyticFunction f({t}, sqr(t)*exp(sin(t))); - SampledTraj x = AnalyticTraj(f,{0,10}).sampled(1e-3); - SampledTraj s = AnalyticTraj(AnalyticFunction({t},exp(sin(t))*(2*t+sqr(t)*cos(t))),{0,10}).sampled(1e-2); + SampledTraj x = AnalyticTraj({0,10},f).sampled(1e-3); + SampledTraj s = AnalyticTraj({0,10},AnalyticFunction({t},exp(sin(t))*(2*t+sqr(t)*cos(t)))).sampled(1e-2); //DefaultFigure::plot_trajectory(x); //DefaultFigure::plot_trajectory(x.derivative(), Color::blue()); diff --git a/tests/core/trajectory/codac2_tests_SampledTraj.py b/tests/core/trajectory/codac2_tests_SampledTraj.py index c97be21ab..da0072f37 100644 --- a/tests/core/trajectory/codac2_tests_SampledTraj.py +++ b/tests/core/trajectory/codac2_tests_SampledTraj.py @@ -64,7 +64,7 @@ def test_SampledTraj(self): f = AnalyticFunction( [t], cos(t) ) - analytic_traj = AnalyticTraj(f, [-math.pi,math.pi]) + analytic_traj = AnalyticTraj([-math.pi,math.pi],f) sampled_traj = analytic_traj.sampled(1e-2) g = sampled_traj.as_function() @@ -85,7 +85,7 @@ def test_SampledTraj(self): vec(2*cos(t),sin(2*t)) ) - analytic_traj = AnalyticTraj(f, [0,5]) + analytic_traj = AnalyticTraj([0,5],f) sampled_traj = analytic_traj.sampled(1e-2) g = sampled_traj.as_function() @@ -122,8 +122,8 @@ def test_SampledTraj(self): t = ScalarVar() f = AnalyticFunction([t], sqr(t)*exp(sin(t))) - x = AnalyticTraj(f,[0,10]).sampled(1e-3) - s = AnalyticTraj(AnalyticFunction([t],exp(sin(t))*(2*t+sqr(t)*cos(t))),[0,10]).sampled(1e-2) + x = AnalyticTraj([0,10],f).sampled(1e-3) + s = AnalyticTraj([0,10],AnalyticFunction([t],exp(sin(t))*(2*t+sqr(t)*cos(t)))).sampled(1e-2) d = x.derivative() p = d.primitive() From 9f57b9b0de7b41cca0d9b3e65b4456198136c9bf Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 16:33:43 +0200 Subject: [PATCH 17/21] [doc] added manual page on how to load SampledTraj from numpy array --- doc/manual/manual/tools/index.rst | 3 +- doc/manual/manual/tools/sampled_traj_npz.rst | 66 ++++++++++++++++++++ 2 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 doc/manual/manual/tools/sampled_traj_npz.rst diff --git a/doc/manual/manual/tools/index.rst b/doc/manual/manual/tools/index.rst index 88bc066a1..c774c6c8e 100644 --- a/doc/manual/manual/tools/index.rst +++ b/doc/manual/manual/tools/index.rst @@ -8,4 +8,5 @@ Tools serialization.rst registration.rst - octasym.rst \ No newline at end of file + octasym.rst + sampled_traj_npz.rst \ No newline at end of file diff --git a/doc/manual/manual/tools/sampled_traj_npz.rst b/doc/manual/manual/tools/sampled_traj_npz.rst new file mode 100644 index 000000000..822ce9b6e --- /dev/null +++ b/doc/manual/manual/tools/sampled_traj_npz.rst @@ -0,0 +1,66 @@ +.. _sec-trajectories-sampledtraj: + +Sampled trajectories +==================== + +In Python, the ``SampledTraj`` name is a convenience wrapper that mimics the +C++ template deduction style. Depending on the provided samples, it builds and +returns one of the following objects: + +- ``SampledTraj_Scalar`` +- ``SampledTraj_Vector`` +- ``SampledTraj_Matrix`` + +This keeps the user-facing syntax short and consistent with ``AnalyticTraj``. + + +Loading a sampled trajectory from a ``.npz`` file +------------------------------------------------- + +A sampled trajectory cannot be constructed directly from a file path. +The recommended workflow is: + +1. load the ``.npz`` file with ``numpy.load``; +2. extract the arrays containing the sampling times and sampled values; +3. call ``SampledTraj(t, x)``. + +The wrapper then deduces the appropriate trajectory type from ``x``. + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: python + + import numpy as np + from codac import * + + data = np.load("traj_vec.npz") + traj = SampledTraj(data["t"], data["x"]) + + print(type(traj)) + +In the above example, if ``x`` is a 2D array of shape ``(N,n)``, then +``traj`` is a ``SampledTraj_Vector``. + +Another example: + +.. tabs:: + + .. group-tab:: Python + + .. code-block:: python + + import numpy as np + from codac import * + + t = np.array([0.0, 0.5, 1.0, 1.5]) + x = np.array([ + [0.0, 1.0], + [0.5, 1.5], + [1.0, 2.0], + [1.5, 2.5], + ]) + + traj = SampledTraj(t, x) + print(traj) # outputs: SampledTraj. [0, 1.5]↦[[0, 1.5][1, 2.5]], 4 pts \ No newline at end of file From ce38806771d108b08accabe89f3c1f8ca5d09146 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 17:11:23 +0200 Subject: [PATCH 18/21] [src] using Index = Eigen::Index; --- README.md | 4 ++-- src/core/tools/codac2_Index.h | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 1b23427c9..f6e21a60f 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ -# [Codac: constraint-programming for robotics](http://codac.io/v2) [![Build Status](https://github.com/codac-team/codac/workflows/.github/workflows/tests.yml/badge.svg)](https://github.com/codac-team/codac/actions) +# [Codac: constraint-programming for robotics](http://codac.io) [![Build Status](https://github.com/codac-team/codac/workflows/.github/workflows/tests.yml/badge.svg)](https://github.com/codac-team/codac/actions) -See the official website: http://codac.io/v2 +See the official website: http://codac.io Codac (Catalog Of Domains And Contractors) is a C++/Python/Matlab library providing tools for interval computations and constraint programming over real numbers, trajectories and sets. It has numerous applications in parameter estimation, guaranteed integration, robot localization, and provides reliable outputs. diff --git a/src/core/tools/codac2_Index.h b/src/core/tools/codac2_Index.h index 874b08182..d3ff59aee 100644 --- a/src/core/tools/codac2_Index.h +++ b/src/core/tools/codac2_Index.h @@ -11,6 +11,5 @@ namespace codac2 { - // The Index type is the same as for Eigen - typedef long int Index; + using Index = Eigen::Index; } \ No newline at end of file From 727348db3f39d3ef95837c004d7deb01f9eb64d5 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 19:25:04 +0200 Subject: [PATCH 19/21] [src] using Index = std::ptrdiff_t; (default Eigen type) --- src/core/tools/codac2_Index.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/core/tools/codac2_Index.h b/src/core/tools/codac2_Index.h index d3ff59aee..cd3068f25 100644 --- a/src/core/tools/codac2_Index.h +++ b/src/core/tools/codac2_Index.h @@ -8,8 +8,10 @@ */ #pragma once +#include namespace codac2 { - using Index = Eigen::Index; + // The Index type is the same as for Eigen + using Index = std::ptrdiff_t; } \ No newline at end of file From 15c458d7e8cfdf897cda6a84fec749db552a87c6 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 19:57:40 +0200 Subject: [PATCH 20/21] [tests] unsupported character for Windows --- doc/manual/manual/tubes/src.cpp | 8 ++++---- doc/manual/manual/tubes/src.py | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/manual/manual/tubes/src.cpp b/doc/manual/manual/tubes/src.cpp index ee1c42e2b..8e3a932f3 100644 --- a/doc/manual/manual/tubes/src.cpp +++ b/doc/manual/manual/tubes/src.cpp @@ -66,15 +66,15 @@ TEST_CASE("TDomain class - manual") SlicedTube x(td, Interval(0,1)); SlicedTube v(td, Interval(-1,1)); - cout << x << endl; // outputs [0,2]↦[0,1], 2 slices - cout << v << endl; // outputs [0,2]↦[0,1], 2 slices + cout << x << endl; // outputs [0,2]->[0,1], 2 slices + cout << v << endl; // outputs [0,2]->[0,1], 2 slices size_t n = td->nb_tslices(); // 2: [0,1],[1,2] x.set({0.5,1}, 1.3); // local update, will refine the partition at t=1.3 size_t m = td->nb_tslices(); // now 4: [0,1],[1,1.3],[1.3],[1.3,2] - cout << x << endl; // outputs [0,2]↦[-1,1], 4 slices - cout << v << endl; // outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + cout << x << endl; // outputs [0,2]->[-1,1], 4 slices + cout << v << endl; // outputs [0,2]->[-1,1], 4 slices (v is also impacted by x.set(..)) // [tdomain-class-4-end] CHECK(n == 2); CHECK(m == 4); diff --git a/doc/manual/manual/tubes/src.py b/doc/manual/manual/tubes/src.py index 00e939c3c..23d27c3e6 100644 --- a/doc/manual/manual/tubes/src.py +++ b/doc/manual/manual/tubes/src.py @@ -53,15 +53,15 @@ def tests_TDomain_manual(test): x = SlicedTube(td, Interval(0,1)) v = SlicedTube(td, Interval(-1,1)) - print(x) # outputs [0,2]↦[0,1], 2 slices - print(v) # outputs [0,2]↦[0,1], 2 slices + print(x) # outputs [0,2]->[0,1], 2 slices + print(v) # outputs [0,2]->[0,1], 2 slices n = td.nb_tslices() # 2: [0,1],[1,2] x.set([0.5,1], 1.3) # local update, will refine the partition at t=1.3 m = td.nb_tslices() # now 4: [0,1],[1,1.3],[1.3],[1.3,2] - print(x) # outputs [0,2]↦[-1,1], 4 slices - print(v) # outputs [0,2]↦[-1,1], 4 slices (v is also impacted by x.set(..)) + print(x) # outputs [0,2]->[-1,1], 4 slices + print(v) # outputs [0,2]->[-1,1], 4 slices (v is also impacted by x.set(..)) # [tdomain-class-4-end] test.assertTrue(n == 2) From e11d52a5dedde6d9ef43d4a2bc9291404f557a42 Mon Sep 17 00:00:00 2001 From: Simon Rohou Date: Thu, 16 Apr 2026 21:16:05 +0200 Subject: [PATCH 21/21] [tests] unsupported character for Windows...... --- src/core/domains/tube/codac2_Slice.h | 2 +- src/core/domains/tube/codac2_SlicedTube.h | 2 +- src/core/functions/analytic/codac2_AnalyticFunction.h | 2 +- src/core/trajectory/codac2_SampledTraj.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/domains/tube/codac2_Slice.h b/src/core/domains/tube/codac2_Slice.h index 3fcf913a8..4d74f0389 100644 --- a/src/core/domains/tube/codac2_Slice.h +++ b/src/core/domains/tube/codac2_Slice.h @@ -546,7 +546,7 @@ namespace codac2 friend inline std::ostream& operator<<(std::ostream& os, const Slice& x) { os << x.t0_tf() - << "↦" << x.codomain() + << "->" << x.codomain() << std::flush; return os; } diff --git a/src/core/domains/tube/codac2_SlicedTube.h b/src/core/domains/tube/codac2_SlicedTube.h index d5835ff41..f8dca4c91 100644 --- a/src/core/domains/tube/codac2_SlicedTube.h +++ b/src/core/domains/tube/codac2_SlicedTube.h @@ -656,7 +656,7 @@ namespace codac2 friend inline std::ostream& operator<<(std::ostream& os, const SlicedTube& x) { os << x.t0_tf() - << "↦" << (x.is_empty() ? x.empty_value() : x.codomain()) + << "->" << (x.is_empty() ? x.empty_value() : x.codomain()) << ", " << x.nb_slices() << " slice" << (x.nb_slices() > 1 ? "s" : "") << std::flush; diff --git a/src/core/functions/analytic/codac2_AnalyticFunction.h b/src/core/functions/analytic/codac2_AnalyticFunction.h index 1985f8358..337a64d03 100644 --- a/src/core/functions/analytic/codac2_AnalyticFunction.h +++ b/src/core/functions/analytic/codac2_AnalyticFunction.h @@ -256,7 +256,7 @@ namespace codac2 os << "("; for(size_t i = 0 ; i < f.args().size() ; i++) os << (i!=0 ? "," : "") << f.args()[i]->name(); - os << ") ↦ " << f.expr()->str(); + os << ") -> " << f.expr()->str(); return os; } diff --git a/src/core/trajectory/codac2_SampledTraj.h b/src/core/trajectory/codac2_SampledTraj.h index 82e9f8752..3aaaa0537 100644 --- a/src/core/trajectory/codac2_SampledTraj.h +++ b/src/core/trajectory/codac2_SampledTraj.h @@ -402,7 +402,7 @@ namespace codac2 template inline std::ostream& operator<<(std::ostream& os, const SampledTraj& x) { - os << "SampledTraj. " << x.tdomain() << "↦"; + os << "SampledTraj. " << x.tdomain() << "->"; if constexpr(std::is_same_v) { os << "[";