857 lines
23 KiB
C++
857 lines
23 KiB
C++
/*
|
|
[auto_generated]
|
|
libs/numeric/odeint/test/stepper_copying.cpp
|
|
|
|
[begin_description]
|
|
This file tests the copying of the steppers.
|
|
[end_description]
|
|
|
|
Copyright 2011-2012 Karsten Ahnert
|
|
Copyright 2011-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)
|
|
*/
|
|
|
|
// disable checked iterator warning for msvc
|
|
#include <boost/config.hpp>
|
|
#ifdef BOOST_MSVC
|
|
#pragma warning(disable:4996)
|
|
#endif
|
|
|
|
|
|
#define BOOST_TEST_MODULE odeint_stepper_copying
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
#include <boost/type_traits/integral_constant.hpp>
|
|
|
|
//#include <boost/numeric/odeint/util/construct.hpp>
|
|
//#include <boost/numeric/odeint/util/destruct.hpp>
|
|
#include <boost/numeric/odeint/util/copy.hpp>
|
|
|
|
#include <boost/numeric/odeint/util/state_wrapper.hpp>
|
|
|
|
#include <boost/numeric/odeint/stepper/euler.hpp>
|
|
#include <boost/numeric/odeint/stepper/runge_kutta4_classic.hpp>
|
|
#include <boost/numeric/odeint/stepper/runge_kutta4.hpp>
|
|
#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp>
|
|
#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp>
|
|
#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
|
|
#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
|
|
#include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp>
|
|
|
|
template< class T , size_t Dim >
|
|
class test_array
|
|
{
|
|
public:
|
|
|
|
const static size_t dim = Dim;
|
|
typedef T value_type;
|
|
typedef value_type* iterator;
|
|
typedef const value_type* const_iterator;
|
|
|
|
value_type& operator[]( size_t i )
|
|
{
|
|
return m_data[i];
|
|
}
|
|
|
|
const value_type& operator[]( size_t i ) const
|
|
{
|
|
return m_data[i];
|
|
}
|
|
|
|
iterator begin( void )
|
|
{
|
|
return m_data;
|
|
}
|
|
|
|
iterator end( void )
|
|
{
|
|
return m_data + dim;
|
|
}
|
|
|
|
const_iterator begin( void ) const
|
|
{
|
|
return m_data;
|
|
}
|
|
|
|
const_iterator end( void ) const
|
|
{
|
|
return m_data + dim;
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
value_type m_data[dim];
|
|
};
|
|
|
|
template< class T , size_t Dim >
|
|
class test_array2 : public test_array< T , Dim >
|
|
{
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
* Explicit testing if copying was successful is difficult,
|
|
* hence we only test if the number of copy operations is right.
|
|
*
|
|
* Otherwise one has to prepare the states.
|
|
*/
|
|
|
|
size_t construct_count = 0;
|
|
size_t construct2_count = 0;
|
|
size_t destruct_count = 0;
|
|
size_t destruct2_count = 0;
|
|
size_t copy_count = 0;
|
|
size_t copy2_count = 0;
|
|
|
|
void reset_counter( void )
|
|
{
|
|
construct_count = 0;
|
|
construct2_count = 0;
|
|
destruct_count = 0;
|
|
destruct2_count = 0;
|
|
copy_count = 0;
|
|
copy2_count = 0;
|
|
}
|
|
|
|
|
|
namespace boost { namespace numeric { namespace odeint {
|
|
|
|
//provide the state_wrapper
|
|
template< class T , size_t Dim >
|
|
struct state_wrapper< test_array< T , Dim > >
|
|
{
|
|
typedef state_wrapper< test_array< T , Dim > > state_wrapper_type;
|
|
typedef test_array< T , Dim > state_type;
|
|
typedef T value_type;
|
|
|
|
state_type m_v;
|
|
|
|
state_wrapper() : m_v()
|
|
{
|
|
construct_count++;
|
|
}
|
|
|
|
state_wrapper( const state_type &v ) : m_v( v )
|
|
{
|
|
construct_count++;
|
|
copy_count++;
|
|
}
|
|
|
|
state_wrapper( const state_wrapper_type &x ) : m_v( x.m_v )
|
|
{
|
|
construct_count++;
|
|
copy_count++;
|
|
}
|
|
|
|
state_wrapper_type& operator=( const state_wrapper_type &x )
|
|
{
|
|
copy_count++;
|
|
return *this;
|
|
}
|
|
|
|
~state_wrapper()
|
|
{
|
|
destruct_count++;
|
|
}
|
|
};
|
|
|
|
//provide the state_wrapper
|
|
template< class T , size_t Dim >
|
|
struct state_wrapper< test_array2< T , Dim > >
|
|
{
|
|
typedef state_wrapper< test_array2< T , Dim > > state_wrapper_type;
|
|
typedef test_array2< T , Dim > state_type;
|
|
typedef T value_type;
|
|
|
|
state_type m_v;
|
|
|
|
state_wrapper() : m_v()
|
|
{
|
|
construct2_count++;
|
|
}
|
|
|
|
state_wrapper( const state_type &v ) : m_v( v )
|
|
{
|
|
construct2_count++;
|
|
copy2_count++;
|
|
}
|
|
|
|
state_wrapper( const state_wrapper_type &x ) : m_v( x.m_v )
|
|
{
|
|
construct2_count++;
|
|
copy2_count++;
|
|
}
|
|
|
|
state_wrapper_type& operator=( const state_wrapper_type &x )
|
|
{
|
|
copy2_count++;
|
|
return *this;
|
|
}
|
|
|
|
~state_wrapper()
|
|
{
|
|
destruct2_count++;
|
|
}
|
|
};
|
|
|
|
|
|
} } }
|
|
|
|
|
|
|
|
typedef test_array< double , 3 > state_type;
|
|
typedef test_array2< double , 3 > deriv_type;
|
|
typedef boost::numeric::odeint::euler< state_type , double , deriv_type > euler_type;
|
|
typedef boost::numeric::odeint::runge_kutta4_classic< state_type , double , deriv_type > rk4_type;
|
|
typedef boost::numeric::odeint::runge_kutta4< state_type , double , deriv_type > rk4_generic_type;
|
|
typedef boost::numeric::odeint::runge_kutta_cash_karp54_classic< state_type , double , deriv_type > rk54_type;
|
|
typedef boost::numeric::odeint::runge_kutta_cash_karp54< state_type , double , deriv_type > rk54_generic_type;
|
|
typedef boost::numeric::odeint::runge_kutta_dopri5< state_type , double , deriv_type > dopri5_type;
|
|
typedef boost::numeric::odeint::controlled_runge_kutta< rk54_type > controlled_rk54_type;
|
|
typedef boost::numeric::odeint::controlled_runge_kutta< rk54_generic_type > controlled_rk54_generic_type;
|
|
typedef boost::numeric::odeint::controlled_runge_kutta< dopri5_type > controlled_dopri5_type;
|
|
typedef boost::numeric::odeint::dense_output_runge_kutta< euler_type > dense_output_euler_type;
|
|
typedef boost::numeric::odeint::dense_output_runge_kutta< controlled_dopri5_type > dense_output_dopri5_type;
|
|
|
|
#define CHECK_COUNTERS( c1 , c2 , c3 , c4 , c5 , c6 ) \
|
|
BOOST_CHECK_EQUAL( construct_count , size_t( c1 ) ); \
|
|
BOOST_CHECK_EQUAL( construct2_count , size_t( c2 ) ); \
|
|
BOOST_CHECK_EQUAL( destruct_count , size_t( c3 ) ); \
|
|
BOOST_CHECK_EQUAL( destruct2_count , size_t( c4) ); \
|
|
BOOST_CHECK_EQUAL( copy_count , size_t( c5 ) ) ; \
|
|
BOOST_CHECK_EQUAL( copy2_count, size_t( c6 ) )
|
|
|
|
BOOST_AUTO_TEST_SUITE( stepper_copying )
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 1 deriv_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_euler_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
euler_type euler;
|
|
}
|
|
CHECK_COUNTERS( 0 , 1 , 0 , 1 , 0 , 0 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_euler_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
euler_type euler;
|
|
euler_type euler2( euler );
|
|
}
|
|
CHECK_COUNTERS( 0 , 1 + 1 , 0 , 1 + 1 , 0 , 1 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_euler_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
euler_type euler;
|
|
euler_type euler2;
|
|
euler2 = euler;
|
|
}
|
|
CHECK_COUNTERS( 0 , 2 , 0 , 2 , 0 , 1 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_rk4
|
|
* 1 state_type in explicit_rk4
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_type rk4;
|
|
}
|
|
CHECK_COUNTERS( 1 , 4 , 1 , 4 , 0 , 0 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
* 2 * 3 deriv_type in explicit_rk4
|
|
* 2 * 1 state_type in explicit_rk4
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_stepper_base
|
|
* 1 state_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_type rk4;
|
|
rk4_type rk4_2( rk4 );
|
|
}
|
|
CHECK_COUNTERS( 2 , 8 , 2 , 8 , 1 , 4 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
* 2 * 3 deriv_type in explicit_rk4
|
|
* 2 * 1 state_type in explicit_rk4
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_stepper_base
|
|
* 1 state_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_type rk4;
|
|
rk4_type rk4_2;
|
|
rk4 = rk4_2;
|
|
}
|
|
CHECK_COUNTERS( 2 , 8 , 2 , 8 , 1 , 4 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_rk4
|
|
* 1 state_type in explicit_rk4
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_generic_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_generic_type rk4;
|
|
}
|
|
CHECK_COUNTERS( 1 , 4 , 1 , 4 , 0 , 0 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
* 2 * 3 deriv_type in explicit_rk4
|
|
* 2 * 1 state_type in explicit_rk4
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_stepper_base
|
|
* 1 state_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_generic_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_generic_type rk4;
|
|
rk4_generic_type rk4_2( rk4 );
|
|
}
|
|
CHECK_COUNTERS( 2 , 8 , 2 , 8 , 1 , 4 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
* 2 * 3 deriv_type in explicit_rk4
|
|
* 2 * 1 state_type in explicit_rk4
|
|
*
|
|
* Copying
|
|
* 1 deriv_type in explicit_stepper_base
|
|
* 3 deriv_type in explicit_stepper_base
|
|
* 1 state_type in explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( explicit_rk4_generic_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
rk4_generic_type rk4;
|
|
rk4_generic_type rk4_2;
|
|
rk4 = rk4_2;
|
|
}
|
|
CHECK_COUNTERS( 2 , 8 , 2 , 8 , 1 , 4 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 explicit_rk54_ck:
|
|
* 2 * 1 deriv_type in explicit_error_stepper_base
|
|
* 2 * 5 deriv_type in explicit_error_rk54_ck
|
|
* 2 * 1 state_type in explicit_error_rk4
|
|
* 1 controlled_stepper:
|
|
* 1 deriv_type
|
|
* 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_rk54_ck:
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck
|
|
* 1 state_type from explicit_error_rk54_ck
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_type stepper;
|
|
}
|
|
CHECK_COUNTERS( 4 , 13 , 4 , 13 , 1 , 6 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 3 explicit_rk54_ck:
|
|
* 3 * 1 deriv_type in explicit_error_stepper_base
|
|
* 3 * 5 deriv_type in explicit_error_rk54_ck
|
|
* 3 * 1 state_type in explicit_error_rk4
|
|
* 2 controlled_stepper:
|
|
* 2 * 1 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_rk54_ck:
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck
|
|
* 1 state_type from explicit_error_rk54_ck
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck
|
|
* 1 state_type from explicit_error_rk54_ck
|
|
* 1 deriv_type from controlled_error_stepper
|
|
* 2 state_type from controlled_error_stepper
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_type stepper;
|
|
controlled_rk54_type stepper2( stepper );
|
|
}
|
|
CHECK_COUNTERS( 7 , 20 , 7 , 20 , 4 , 13 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 4 explicit_rk54_ck:
|
|
* 4 * 1 deriv_type in explicit_error_stepper_base
|
|
* 4 * 5 deriv_type in explicit_error_rk54_ck
|
|
* 4 * 1 state_type in explicit_error_rk4
|
|
* 2 controlled_stepper:
|
|
* 2 * 1 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 2 copy process of explicit_rk54_ck:
|
|
* 2 * 1 deriv_type from explicit_error_stepper_base
|
|
* 2 * 5 deriv_type from explicit_error_rk54_ck
|
|
* 2 * 1 state_type from explicit_error_rk54_ck
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck
|
|
* 1 state_type from explicit_error_rk54_ck
|
|
* 1 deriv_type from controlled_error_stepper
|
|
* 2 state_type from controlled_error_stepper
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_type stepper;
|
|
controlled_rk54_type stepper2;
|
|
stepper2 = stepper;
|
|
}
|
|
CHECK_COUNTERS( 8 , 26 , 8 , 26 , 5 , 19 );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 explicit_rk54_ck_generic:
|
|
* 2 * 1 deriv_type in explicit_error_stepper_base
|
|
* 2 * 5 deriv_type in explicit_error_rk54_ck_generic
|
|
* 2 * 1 state_type in explicit_error_rk54_ck_generic
|
|
* 1 controlled_stepper:
|
|
* 1 deriv_type
|
|
* 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_rk54_ck_generic:
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck_generic
|
|
* 1 state_type from explicit_error_rk54_ck_generic
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_generic_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_generic_type stepper;
|
|
}
|
|
CHECK_COUNTERS( 4 , 13 , 4 , 13 , 1 , 6 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 3 explicit_rk54_ck_generic:
|
|
* 3 * 1 deriv_type in explicit_error_stepper_base
|
|
* 3 * 5 deriv_type in explicit_error_rk54_ck_generic
|
|
* 3 * 1 state_type in explicit_error_rk4_generic
|
|
* 2 controlled_stepper:
|
|
* 2 * 1 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_rk54_ck_generic:
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck_generic
|
|
* 1 state_type from explicit_error_rk54_ck_generic
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck_generic
|
|
* 1 state_type from explicit_error_rk54_ck_generic
|
|
* 1 deriv_type from controlled_error_stepper
|
|
* 2 state_type from controlled_error_stepper
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_generic_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_generic_type stepper;
|
|
controlled_rk54_generic_type stepper2( stepper );
|
|
}
|
|
CHECK_COUNTERS( 7 , 20 , 7 , 20 , 4 , 13 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 4 explicit_rk54_ck_generic:
|
|
* 4 * 1 deriv_type in explicit_error_stepper_base
|
|
* 4 * 5 deriv_type in explicit_error_rk54_ck_generic
|
|
* 4 * 1 state_type in explicit_error_rk4_generic
|
|
* 2 controlled_stepper:
|
|
* 2 * 1 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 2 copy process of explicit_rk54_ck_generic:
|
|
* 2 * 1 deriv_type from explicit_error_stepper_base
|
|
* 2 * 5 deriv_type from explicit_error_rk54_ck_generic
|
|
* 2 * 1 state_type from explicit_error_rk54_ck_generic
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 5 deriv_type from explicit_error_rk54_ck_generic
|
|
* 1 state_type from explicit_error_rk54_ck_generic
|
|
* 1 deriv_type from controlled_error_stepper
|
|
* 2 state_type from controlled_error_stepper
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_rk54_generic_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_rk54_generic_type stepper;
|
|
controlled_rk54_generic_type stepper2;
|
|
stepper2 = stepper;
|
|
}
|
|
CHECK_COUNTERS( 8 , 26 , 8 , 26 , 5 , 19 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 explicit_error_dopri5:
|
|
* 2 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 2 * 6 deriv_type in explicit_error_dopri5
|
|
* 2 * 1 state_type in explicit_error_dopri5
|
|
* 1 controlled_error_stepper (fsal):
|
|
* 2 deriv_type
|
|
* 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_dopri5:
|
|
* 1 deriv_type from explicit_error_stepper_base_fsal
|
|
* 6 deriv_type from explicit_error_dopri5
|
|
* 1 state_type from explicit_error_dopri5
|
|
*/
|
|
|
|
BOOST_AUTO_TEST_CASE( controlled_dopri5_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_dopri5_type dopri5;
|
|
}
|
|
CHECK_COUNTERS( 2 * 1 + 2 , 2 * (6+1) + 2 , 2 * 1 + 2 , 2 * (6+1) + 2 , 1 , 1 + 6 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 3 explicit_error_dopri5:
|
|
* 3 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 3 * 6 deriv_type in explicit_error_dopri5
|
|
* 3 * 1 state_type in explicit_error_dopri5
|
|
* 2 controlled_error_stepper (fsal):
|
|
* 2 * 2 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_error_dopri5:
|
|
* 1 deriv_type from explicit_error_stepper_base_fsal
|
|
* 6 deriv_type from explicit_error_error_dopri5
|
|
* 1 state_type from explicit_error_error_dopri5
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base_fsal
|
|
* 6 deriv_type from explicit_error_dopri5
|
|
* 1 state_type from explicit_error_dopri5
|
|
* 2 deriv_type from controlled_error_stepper (fsal)
|
|
* 2 state_type from controlled_error_stepper (fsal)
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_dopri5_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_dopri5_type dopri5;
|
|
controlled_dopri5_type dopri5_2( dopri5 );
|
|
}
|
|
CHECK_COUNTERS( 3 * 1 + 2 * 2 , 3 * (6+1) + 2 * 2 , 3 * 1 + 2 * 2 , 3 * (6+1) + 2 * 2 , 1 + 1 + 2 , 1 + 6 + 1 + 6 + 2 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 4 explicit_error_dopri5:
|
|
* 4 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 4 * 6 deriv_type in explicit_error_dopri5
|
|
* 4 * 1 state_type in explicit_error_dopri5
|
|
* 2 controlled_error_stepper (fsal):
|
|
* 2 * 2 deriv_type
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 2 copy process of explicit_error_dopri5:
|
|
* 2 * 1 deriv_type from explicit_error_stepper_base_fsal
|
|
* 2 * 6 deriv_type from explicit_error_dopri5
|
|
* 2 * 1 state_type from explicit_error_dopri5
|
|
*
|
|
* 1 process of copying controlled_error_stepper
|
|
* 1 deriv_type from explicit_error_stepper_base
|
|
* 6 deriv_type from explicit_error_dopri5
|
|
* 1 state_type from explicit_error_dopri5
|
|
* 2 deriv_type from controlled_error_stepper (fsal)
|
|
* 2 state_type from controlled_error_stepper (fsal)
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( controlled_dopri5_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
controlled_dopri5_type dopri5;
|
|
controlled_dopri5_type dopri5_2;
|
|
dopri5_2 = dopri5;
|
|
}
|
|
CHECK_COUNTERS( 4 * 1 + 2 * 2 , 4 * (1+6) + 2 * 2 , 4 * 1 + 2 * 2 , 4 * (1+6) + 2 * 2 , 2 * 1 + 1 + 2 , 2 * (6+1) + 1 + 6 + 2 );
|
|
}
|
|
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 2 explicit_euler:
|
|
* 2 * 1 deriv_type in explicit_stepper_base
|
|
* 1 dense_output_explicit:
|
|
* 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_euler:
|
|
* 1 deriv_type from explicit_stepper_base
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_euler_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_euler_type euler;
|
|
}
|
|
CHECK_COUNTERS( 2 , 2 * 1 , 2 , 2 * 1 , 0 , 1 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 3 explicit_euler:
|
|
* 3 * 1 deriv_type in explicit_stepper_base
|
|
* 2 dense_output_explicit:
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 1 copy process of explicit_euler:
|
|
* 1 deriv_type from explicit_stepper_base
|
|
*
|
|
* 1 process of copying
|
|
* 1 deriv_type from explicit_stepper_base
|
|
* 2 state_type from dense_output_explicit
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_euler_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_euler_type euler;
|
|
dense_output_euler_type euler2( euler );
|
|
}
|
|
CHECK_COUNTERS( 2 * 2 , 3 * 1 , 2 * 2 , 3 * 1 , 2 , 1 + 1 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 4 explicit_euler:
|
|
* 4 * 1 deriv_type in explicit_stepper_base
|
|
* 2 dense_output_explicit:
|
|
* 2 * 2 state_type
|
|
*
|
|
* Copying
|
|
* 2 copy process of explicit_euler:
|
|
* 2 * 1 deriv_type from explicit_stepper_base
|
|
*
|
|
* 1 process of copying dense_ouput_explicit
|
|
* 1 deriv_type from explicit_stepper_base
|
|
* 2 state_type from dense_output_explicit
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_euler_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_euler_type euler;
|
|
dense_output_euler_type euler2;
|
|
euler2 = euler;
|
|
}
|
|
CHECK_COUNTERS( 2 * 2 , 4 * 1 , 2 * 2 , 4 * 1 , 2 , 2 * 1 + 1 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 3 dense_output_dopri5:
|
|
* 3 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 3 * 6 deriv_type in explicit_error_dopri5
|
|
* 3 * 1 state_type in explicit_error_dopri5
|
|
* 2 controlled_error_stepper (fsal):
|
|
* 2 * 2 state_type
|
|
* 2 * 2 deriv_type
|
|
* 1 dense_output_controlled_explicit:
|
|
* 2 state_type
|
|
* 2 deriv_type
|
|
*
|
|
* Copying
|
|
* 2 copy process of explicit_error_dopri5:
|
|
* 2 * 1 deriv_type from explicit_erro_stepper_base_fsal
|
|
* 2 * 6 deriv_type in explicit_error_dopri5
|
|
* 2 * 1 state_type in explicit_error_dopri5
|
|
* 1 copy process of dense_output_controlled (fsal)
|
|
* 2 state_type
|
|
* 2 deriv_type
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_dopri5_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_dopri5_type dopri5;
|
|
}
|
|
CHECK_COUNTERS( 3*1 + 2*2 + 2 , 3*(1+6) + 2*2 + 2 , 3*1 + 2*2 + 2 , 3*(1+6) + 2*2 + 2 , 2*1 + 2 , 2*(1+6) + 2 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 4 dense_output_dopri5:
|
|
* 4 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 4 * 5 deriv_type in explicit_error_dopri5
|
|
* 4 * 1 state_type in explicit_error_dopri5
|
|
* 3 controlled_error_stepper (fsal):
|
|
* 3 * 2 state_type
|
|
* 3 * 2 deriv_type
|
|
* 2 dense_output_controlled_explicit:
|
|
* 2 * 2 state_type
|
|
* 2 * 2 deriv_type
|
|
*
|
|
* Copying
|
|
* 3 copy process of explicit_error_dopri5:
|
|
* 3 * 1 deriv_type from explicit_erro_stepper_base_fsal
|
|
* 3 * 6 deriv_type in explicit_error_dopri5
|
|
* 3 * 1 state_type in explicit_error_dopri5
|
|
* 2 copy process of controlled_error_stepper (fsal):
|
|
* 2 * 2 state_type
|
|
* 2 * 2 deriv_type
|
|
* 1 copy process of dense_output_controlled_explicit:
|
|
* 2 state_type
|
|
* 2 deriv_type
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_dopri5_copy_construct )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_dopri5_type dopri5;
|
|
dense_output_dopri5_type dopri5_2( dopri5 );
|
|
}
|
|
CHECK_COUNTERS( 4*1 + 3*2 + 2*2 , 4*(1+6) + 3*2 + 2*2 , 4*1 + 3*2 + 2*2 , 4*(1+6) + 3*2 + 2*2 , 3*1 + 2*2 + 1*2 , 3*(6+1) + 2*2 + 2 );
|
|
}
|
|
|
|
/*
|
|
* Construct + Destruct
|
|
* 6 dense_output_dopri5:
|
|
* 6 * 1 deriv_type in explicit_error_stepper_base_fsal
|
|
* 6 * 6 deriv_type in explicit_error_dopri5
|
|
* 6 * 1 state_type in explicit_error_dopri5
|
|
* 4 controlled_error_stepper (fsal):
|
|
* 4 * 2 state_type
|
|
* 4 * 2 deriv_type
|
|
* 2 dense_output_controlled_explicit:
|
|
* 2 * 2 state_type
|
|
* 2 * 2 deriv_type
|
|
*
|
|
* Copying
|
|
* 5 copy process of explicit_error_dopri5:
|
|
* 5 * 1 deriv_type from explicit_erro_stepper_base_fsal
|
|
* 5 * 6 deriv_type in explicit_error_dopri5
|
|
* 5 * 1 state_type in explicit_error_dopri5
|
|
* 3 copy process of controlled_error_stepper (fsal):
|
|
* 3 * 2 state_type
|
|
* 3 * 2 deriv_type
|
|
* 1 copy process of dense_output_controlled_explicit:
|
|
* 2 state_type
|
|
* 2 deriv_type
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( dense_output_dopri5_assign )
|
|
{
|
|
reset_counter();
|
|
{
|
|
dense_output_dopri5_type dopri5;
|
|
dense_output_dopri5_type dopri5_2;
|
|
dopri5_2 = dopri5;
|
|
}
|
|
CHECK_COUNTERS( 6*1 + 4*2 + 2*2 , 6*(6+1) + 4*2 + 2*2 , 6*1 + 4*2 + 2*2 , 6*(6+1) + 4*2 + 2*2 , 5*1 + 3*2 + 2 , 5*(6+1) + 3*2 + 2 );
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
|