boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/odeint/stepper/controlled_step_result.hpp

@@ -0,0 +1,42 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/controlled_step_result.hpp
+
+ [begin_description]
+ Defines the result type for all controlled stepper.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/**
+ * \enum controlled_step_result
+ *
+ * \brief Enum representing the return values of the controlled steppers.
+ */
+typedef enum
+{
+    success , /**< The trial step was successful, hence the state and the time have been advanced. */
+    fail      /**< The step was not successful and might possibly be repeated with a small step size. */
+} controlled_step_result;
+
+} // namespace odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED

package/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp

@@ -0,0 +1,476 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
+
+ [begin_description]
+ Implementation of the Dense-output stepper for all steppers. Note, that this class does
+ not computes the result but serves as an interface.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+
+
+#include <utility>
+#include <stdexcept>
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class Stepper , class StepperCategory = typename Stepper::stepper_category >
+class dense_output_runge_kutta;
+
+
+/**
+ * \brief The class representing dense-output Runge-Kutta steppers.
+ * \note In this stepper, the initialize method has to be called before using
+ * the do_step method.
+ *
+ * The dense-output functionality allows to interpolate the solution between
+ * subsequent integration points using intermediate results obtained during the
+ * computation. This version works based on a normal stepper without step-size
+ * control. 
+ * 
+ *
+ * \tparam Stepper The stepper type of the underlying algorithm.
+ */
+template< class Stepper >
+class dense_output_runge_kutta< Stepper , stepper_tag >
+{
+
+public:
+
+    /*
+     * We do not need all typedefs.
+     */
+    typedef Stepper stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+    typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type;
+
+
+    /**
+     * \brief Constructs the dense_output_runge_kutta class. An instance of the
+     * underlying stepper can be provided.
+     * \param stepper An instance of the underlying stepper.
+     */
+    dense_output_runge_kutta( const stepper_type &stepper = stepper_type() )
+    : m_stepper( stepper ) , m_resizer() ,
+      m_x1() , m_x2() , m_current_state_x1( true ) , 
+      m_t() , m_t_old() , m_dt()
+    { } 
+
+
+    /**
+     * \brief Initializes the stepper. Has to be called before do_step can be 
+     * used to set the initial conditions and the step size.
+     * \param x0 The initial state of the ODE which should be solved.
+     * \param t0 The initial time, at which the step should be performed.
+     * \param dt0 The step size.
+     */
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    {
+        m_resizer.adjust_size(x0, [this](auto&& arg) { return this->resize_impl<StateType>(std::forward<decltype(arg)>(arg)); });
+        boost::numeric::odeint::copy( x0 , get_current_state() );
+        m_t = t0;
+        m_dt = dt0;
+    }
+
+    /**
+     * \brief Does one time step.
+     * \note initialize has to be called before using this method to set the
+     * initial conditions x,t and the stepsize.
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \return Pair with start and end time of the integration step.
+     */
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        m_stepper.do_step( system , get_current_state() , m_t , get_old_state() , m_dt );
+        m_t_old = m_t;
+        m_t += m_dt;
+        toggle_current_state();
+        return std::make_pair( m_t_old , m_t );
+    }
+
+    /*
+     * The next two overloads are needed to solve the forwarding problem
+     */
+    
+    /**
+     * \brief Calculates the solution at an intermediate point.
+     * \param t The time at which the solution should be calculated, has to be
+     * in the current time interval.
+     * \param x The output variable where the result is written into.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    {
+        if( t == current_time() )
+        {
+            boost::numeric::odeint::copy( get_current_state() , x );
+        }
+        m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+    /**
+     * \brief Calculates the solution at an intermediate point. Solves the forwarding problem
+     * \param t The time at which the solution should be calculated, has to be
+     * in the current time interval.
+     * \param x The output variable where the result is written into, can be a boost range.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x ) const
+    {
+        m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+    /**
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+        m_stepper.stepper().resize( x );
+    }
+
+    /**
+     * \brief Returns the current state of the solution.
+     * \return The current state of the solution x(t).
+     */
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    /**
+     * \brief Returns the current time of the solution.
+     * \return The current time of the solution t.
+     */
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    /**
+     * \brief Returns the last state of the solution.
+     * \return The last state of the solution x(t-dt).
+     */
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    /**
+     * \brief Returns the last time of the solution.
+     * \return The last time of the solution t-dt.
+     */
+    time_type previous_time( void ) const
+    {
+        return m_t_old;
+    }
+
+    /**
+     * \brief Returns the current time step.
+     * \return dt.
+     */
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+
+private:
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        return resized;
+    }
+
+
+    stepper_type m_stepper;
+    resizer_type m_resizer;
+    wrapped_state_type m_x1 , m_x2;
+    bool m_current_state_x1;    // if true, the current state is m_x1
+    time_type m_t , m_t_old , m_dt;
+
+};
+
+
+
+
+
+/**
+ * \brief The class representing dense-output Runge-Kutta steppers with FSAL property.
+ *
+ * The interface is the same as for dense_output_runge_kutta< Stepper , stepper_tag >.
+ * This class provides dense output functionality based on methods with step size controlled 
+ * 
+ *
+ * \tparam Stepper The stepper type of the underlying algorithm.
+ */
+template< class Stepper >
+class dense_output_runge_kutta< Stepper , explicit_controlled_stepper_fsal_tag >
+{
+public:
+
+    /*
+     * We do not need all typedefs.
+     */
+    typedef Stepper controlled_stepper_type;
+
+    typedef typename controlled_stepper_type::stepper_type stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+    typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type;
+
+
+    dense_output_runge_kutta( const controlled_stepper_type &stepper = controlled_stepper_type() )
+    : m_stepper( stepper ) , m_resizer() ,
+      m_current_state_x1( true ) ,
+      m_x1() , m_x2() , m_dxdt1() , m_dxdt2() ,
+      m_t() , m_t_old() , m_dt() ,
+      m_is_deriv_initialized( false )
+    { }
+
+
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    {
+        m_resizer.adjust_size(x0, [this](auto&& arg) { return this->resize<StateType>(std::forward<decltype(arg)>(arg)); });
+        boost::numeric::odeint::copy( x0 , get_current_state() );
+        m_t = t0;
+        m_dt = dt0;
+        m_is_deriv_initialized = false;
+    }
+
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        if( !m_is_deriv_initialized )
+        {
+            typename odeint::unwrap_reference< System >::type &sys = system;
+            sys( get_current_state() , get_current_deriv() , m_t );
+            m_is_deriv_initialized = true;
+        }
+
+        failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+        controlled_step_result res = fail;
+        m_t_old = m_t;
+        do
+        {
+            res = m_stepper.try_step( system , get_current_state() , get_current_deriv() , m_t ,
+                                      get_old_state() , get_old_deriv() , m_dt );
+            fail_checker();  // check for overflow of failed steps
+        }
+        while( res == fail );
+        toggle_current_state();
+        return std::make_pair( m_t_old , m_t );
+    }
+
+
+    /*
+     * The two overloads are needed in order to solve the forwarding problem.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old ,
+                                        get_current_state() , get_current_deriv() , m_t );
+    }
+
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x ) const
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old ,
+                                        get_current_state() , get_current_deriv() , m_t );
+    }
+
+
+    template< class StateIn >
+    bool resize( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize( x );
+        m_stepper.stepper().resize( x );
+    }
+
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    time_type previous_time( void ) const
+    {
+        return m_t_old;
+    }
+
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+
+private:
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+
+    deriv_type& get_current_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    const deriv_type& get_current_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    deriv_type& get_old_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+    
+    const deriv_type& get_old_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+
+    
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+    controlled_stepper_type m_stepper;
+    resizer_type m_resizer;
+    bool m_current_state_x1;
+    wrapped_state_type m_x1 , m_x2;
+    wrapped_deriv_type m_dxdt1 , m_dxdt2;
+    time_type m_t , m_t_old , m_dt;
+    bool m_is_deriv_initialized;
+
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED

package/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp

@@ -0,0 +1,148 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
+
+ [begin_description]
+ Algebra caller for the Adams Bashforth stepper.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< size_t Step , class Algebra , class Operations >
+struct adams_bashforth_call_algebra;
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 1 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each3( out , in , steps[0].m_v , typename Operations::template scale_sum2< value_type , Time >( 1.0 , dt * coef[0] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 2 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each4( out , in , steps[0].m_v , steps[1].m_v ,
+                typename Operations::template scale_sum3< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 3 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each5( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v ,
+                typename Operations::template scale_sum4< value_type , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 4 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each6( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v ,
+                typename Operations::template scale_sum5< value_type , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 5 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each7( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v ,
+                typename Operations::template scale_sum6< value_type , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 6 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each8( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v ,
+                typename Operations::template scale_sum7< value_type , Time , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 7 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each9( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v ,
+                            typename Operations::template scale_sum8< value_type , Time , Time , Time , Time , Time , Time >(
+                                1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 8 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each10( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v , steps[7].m_v ,
+                             typename Operations::template scale_sum9< value_type , Time , Time , Time , Time , Time , Time , Time >(
+                                 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] , dt * coef[7] ) );
+    }
+};
+
+
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED