|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r68228 - in sandbox/odeint/branches/karsten: . boost/numeric/odeint/algebra boost/numeric/odeint/stepper boost/numeric/odeint/stepper/base libs/numeric/odeint/ideas libs/numeric/odeint/ideas/units libs/numeric/odeint/test libs/numeric/odeint/test/thrust
From: karsten.ahnert_at_[hidden]
Date: 2011-01-18 08:14:23
Author: karsten
Date: 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
New Revision: 68228
URL: http://svn.boost.org/trac/boost/changeset/68228
Log:
* making the system call compatible with boost::ref
* introducing ideas/units
Added:
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/Jamfile (contents, props changed)
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/adjust_size_units.hpp (contents, props changed)
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_euler_units.hpp (contents, props changed)
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_stepper_base_units.hpp (contents, props changed)
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/standard_operations_units.hpp (contents, props changed)
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/test_units.cpp (contents, props changed)
Text files modified:
sandbox/odeint/branches/karsten/Jamroot | 5 ++-
sandbox/odeint/branches/karsten/boost/numeric/odeint/algebra/standard_resize.hpp | 21 +++++++++------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp | 18 +++++++------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_base.hpp | 29 ++++++++++++---------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_fsal_base.hpp | 31 +++++++++++++---------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp | 15 ++++++----
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/controlled_error_stepper.hpp | 39 ++++++++++++++++------------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_dopri5.hpp | 6 +++-
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_explicit_euler.hpp | 2
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_dopri5.hpp | 20 +++++++++------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_rk54_ck.hpp | 18 +++++++------
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_euler.hpp | 2
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_rk4.hpp | 14 ++++++---
sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/implicit_euler.hpp | 11 +++++---
sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/odeint_ref_problem.cpp | 2
sandbox/odeint/branches/karsten/libs/numeric/odeint/test/check_stepper_concepts.cpp | 53 +++++++++++++++++++++++++++++++++------
sandbox/odeint/branches/karsten/libs/numeric/odeint/test/thrust/Makefile | 2
17 files changed, 181 insertions(+), 107 deletions(-)
Modified: sandbox/odeint/branches/karsten/Jamroot
==============================================================================
--- sandbox/odeint/branches/karsten/Jamroot (original)
+++ sandbox/odeint/branches/karsten/Jamroot 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -20,9 +20,10 @@
# ideas
-build-project libs/numeric/odeint/ideas/butcher ;
-build-project libs/numeric/odeint/ideas/generic_stepper ;
+# build-project libs/numeric/odeint/ideas/butcher ;
+# build-project libs/numeric/odeint/ideas/generic_stepper ;
build-project libs/numeric/odeint/ideas/rosenbrock4 ;
+build-project libs/numeric/odeint/ideas/units ;
# additional tests with external libraries :
build-project libs/numeric/odeint/test/gmp ;
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/algebra/standard_resize.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/algebra/standard_resize.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/algebra/standard_resize.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -67,32 +67,35 @@
{
}
-template< class Container >
-void resize( const Container &x , Container &dxdt )
+template< class Container , class Deriv >
+void resize( const Container &x , Deriv &dxdt )
{
dxdt.resize( x.size() );
}
-template< class Container >
-bool same_size( const Container &x1 , const Container &x2 )
+template< class Container , class Deriv >
+bool same_size( const Container &x1 , const Deriv &x2 )
{
return ( x1.size() == x2.size() );
}
-template< class Container >
-bool adjust_size( const Container &x1 , Container &x2 )
+template< class Container , class Deriv >
+bool adjust_size( const Container &x1 , Deriv &x2 )
{
if( !same_size( x1 , x2 ) )
{
resize( x1 , x2 );
return true;
- } else
+ }
+ else
+ {
return false;
+ }
}
-template< class Container >
-void copy( const Container &from , Container &to )
+template< class Container , class Deriv >
+void copy( const Container &from , Deriv &to )
{
to = from;
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -14,6 +14,7 @@
#define BOOST_NUMERIC_ODEINT_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/adjust_size.hpp>
#include <boost/numeric/odeint/algebra/standard_resize.hpp>
@@ -61,8 +62,7 @@
order_type error_order( void ) const
{
- return error_order_value;
- }
+ return error_order_value; }
@@ -83,32 +83,34 @@
// do_step( system , x , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- system( x , m_dxdt ,t );
+ sys( x , m_dxdt ,t );
this->stepper().do_step_impl( system , x , m_dxdt , t , x , dt , xerr );
}
// do_step( system , x , dxdt , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt , xerr );
}
// do_step( system , in , t , out , dt , xerr )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
- system( in , m_dxdt ,t );
+ sys( in , m_dxdt ,t );
this->stepper().do_step_impl( system , in , m_dxdt , t , out , dt , xerr );
}
// do_step( system , in , dxdt , t , out , dt , xerr )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt , state_type &xerr )
+ void do_step( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt , xerr );
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_base.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_base.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_base.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -14,6 +14,7 @@
#define BOOST_NUMERIC_ODEINT_EXPLICIT_STEPPER_AND_ERROR_STEPPER_BASE_HPP_INCLUDED
#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/adjust_size.hpp>
#include <boost/numeric/odeint/algebra/standard_resize.hpp>
@@ -93,32 +94,34 @@
// do_step( sys , x , t , dt )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- system( x , m_dxdt ,t );
+ sys( x , m_dxdt ,t );
this->stepper().do_step_impl( system , x , m_dxdt , t , x , dt );
}
// do_step( sys , x , dxdt , t , dt )
template< class System >
- void do_step( System &system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
// do_step( sys , in , t , out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
- system( in , m_dxdt ,t );
+ sys( in , m_dxdt ,t );
this->stepper().do_step_impl( system , in , m_dxdt , t , out , dt );
}
// do_step( sys , in , dxdt , t , out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
+ void do_step( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
@@ -130,32 +133,34 @@
// do_step( sys , x , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- system( x , m_dxdt ,t );
+ sys( x , m_dxdt ,t );
this->stepper().do_step_impl( system , x , m_dxdt , t , x , dt , xerr );
}
// do_step( sys , x , dxdt , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , const state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt , xerr );
}
// do_step( sys , in , t , out , dt , xerr )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
- system( in , m_dxdt ,t );
+ sys( in , m_dxdt ,t );
this->stepper().do_step_impl( system , in , m_dxdt , t , out , dt , xerr );
}
// do_step( sys , in , dxdt , t , out , dt , xerr )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt , state_type &xerr )
+ void do_step( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt , xerr );
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_fsal_base.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_fsal_base.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_and_error_stepper_fsal_base.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -14,6 +14,7 @@
#define BOOST_NUMERIC_ODEINT_EXPLICIT_STEPPER_AND_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/adjust_size.hpp>
#include <boost/numeric/odeint/algebra/standard_resize.hpp>
@@ -93,11 +94,12 @@
// do_step( sys , x , t , dt )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt )
{
- if( m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() ) || m_first_call )
+ if( m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() ) || m_first_call )
{
- system( x , m_dxdt ,t );
+ typename boost::unwrap_reference< System >::type &sys = system;
+ sys( x , m_dxdt ,t );
m_first_call = false;
}
this->stepper().do_step_impl( system , x , m_dxdt , t , x , m_dxdt , dt );
@@ -105,7 +107,7 @@
// do_step( sys , x , dxdt , t , dt )
template< class System >
- void do_step( System &system , state_type &x , state_type &dxdt , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , state_type &dxdt , const time_type t , const time_type dt )
{
m_first_call = true;
this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt );
@@ -113,11 +115,12 @@
// do_step( sys , in , t , out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt )
{
if( m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() ) || m_first_call )
{
- system( in , m_dxdt ,t );
+ typename boost::unwrap_reference< System >::type &sys = system;
+ sys( in , m_dxdt ,t );
m_first_call = false;
}
this->stepper().do_step_impl( system , in , m_dxdt , t , out , m_dxdt , dt );
@@ -125,7 +128,7 @@
// do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt_in , const time_type t ,
+ void do_step( System system , const state_type &in , const state_type &dxdt_in , const time_type t ,
state_type &out , state_type &dxdt_out , const time_type dt )
{
m_first_call = true;
@@ -139,11 +142,12 @@
// do_step( sys , x , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt , state_type &xerr )
{
if( m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() ) || m_first_call )
{
- system( x , m_dxdt ,t );
+ typename boost::unwrap_reference< System >::type &sys = system;
+ sys( x , m_dxdt ,t );
m_first_call = false;
}
this->stepper().do_step_impl( system , x , m_dxdt , t , x , m_dxdt , dt , xerr );
@@ -151,7 +155,7 @@
// do_step( sys , x , dxdt , t , dt , xerr )
template< class System >
- void do_step( System &system , state_type &x , state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
+ void do_step( System system , state_type &x , state_type &dxdt , const time_type t , const time_type dt , state_type &xerr )
{
m_first_call = true;
this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt , xerr );
@@ -159,11 +163,12 @@
// do_step( sys , in , t , out , dt , xerr )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
if( m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() ) || m_first_call )
{
- system( in , m_dxdt ,t );
+ typename boost::unwrap_reference< System >::type &sys = system;
+ sys( in , m_dxdt ,t );
m_first_call = false;
}
this->stepper().do_step_impl( system , in , m_dxdt , t , out , m_dxdt , dt , xerr );
@@ -171,7 +176,7 @@
// do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt_in , const time_type t ,
+ void do_step( System system , const state_type &in , const state_type &dxdt_in , const time_type t ,
state_type &out , state_type &dxdt_out , const time_type dt , state_type &xerr )
{
m_first_call = true;
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -14,6 +14,7 @@
#define BOOST_NUMERIC_ODEINT_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/adjust_size.hpp>
#include <boost/numeric/odeint/algebra/standard_resize.hpp>
@@ -76,32 +77,34 @@
// do_step( sys , x , t , dt )
template< class System >
- void do_step( System &system , state_type &x , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , const time_type t , const time_type dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- system( x , m_dxdt ,t );
+ sys( x , m_dxdt ,t );
this->stepper().do_step_impl( system , x , m_dxdt , t , x , dt );
}
// do_step( sys , x , dxdt , t , dt )
template< class System >
- void do_step( System &system , state_type &x , const state_type dxdt , const time_type t , const time_type dt )
+ void do_step( System system , state_type &x , const state_type dxdt , const time_type t , const time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
// do_step( sys , in , t , out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const time_type t , state_type &out , const time_type dt )
+ void do_step( System system , const state_type &in , const time_type t , state_type &out , const time_type dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
- system( in , m_dxdt ,t );
+ sys( in , m_dxdt ,t );
this->stepper().do_step_impl( system , in , m_dxdt , t , out , dt );
}
// do_step( sys , in , dxdt , t , out , dt )
template< class System >
- void do_step( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
+ void do_step( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/controlled_error_stepper.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/controlled_error_stepper.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/controlled_error_stepper.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -16,6 +16,7 @@
#include <cmath>
#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/adjust_size.hpp>
#include <boost/numeric/odeint/stepper/error_checker.hpp>
@@ -99,19 +100,20 @@
// try_step( sys , x , t , dt )
template< class System >
- controlled_step_result try_step( System &sys , state_type &x , time_type &t , time_type &dt )
+ controlled_step_result try_step( System system , state_type &x , time_type &t , time_type &dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_dxdt_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
sys( x , m_dxdt ,t );
- return try_step( sys , x , m_dxdt , t , dt );
+ return try_step( system , x , m_dxdt , t , dt );
}
// try_step( sys , x , dxdt , t , dt )
template< class System >
- controlled_step_result try_step( System &sys , state_type &x , const state_type &dxdt , time_type &t , time_type &dt )
+ controlled_step_result try_step( System system , state_type &x , const state_type &dxdt , time_type &t , time_type &dt )
{
m_xnew_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- controlled_step_result res = try_step( sys , x , dxdt , t , m_xnew , dt );
+ controlled_step_result res = try_step( system , x , dxdt , t , m_xnew , dt );
if( ( res == success_step_size_increased ) || ( res == success_step_size_unchanged ) )
{
boost::numeric::odeint::copy( m_xnew , x );
@@ -121,17 +123,18 @@
// try_step( sys , in , t , out , dt )
template< class System >
- controlled_step_result try_step( System &sys , const state_type &in , time_type &t , state_type &out , time_type &dt )
+ controlled_step_result try_step( System system , const state_type &in , time_type &t , state_type &out , time_type &dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
m_dxdt_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
- sys( in , m_dxdt , t );
- return try_step( sys , in , m_dxdt , t , out , dt );
+ system( in , m_dxdt , t );
+ return try_step( system , in , m_dxdt , t , out , dt );
}
// try_step( sys , in , dxdt , t , out , dt )
template< class System >
- controlled_step_result try_step( System &sys , const state_type &in , const state_type &dxdt , time_type &t , state_type &out , time_type &dt )
+ controlled_step_result try_step( System system , const state_type &in , const state_type &dxdt , time_type &t , state_type &out , time_type &dt )
{
using std::max;
using std::min;
@@ -140,7 +143,7 @@
m_xerr_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
// do one step with error calculation
- m_stepper.do_step( sys , in , dxdt , t , out , dt , m_xerr );
+ m_stepper.do_step( system , in , dxdt , t , out , dt , m_xerr );
m_max_rel_error = m_error_checker.error( in , dxdt , m_xerr , dt );
@@ -275,34 +278,36 @@
// try_step( sys , x , t , dt )
template< class System >
- controlled_step_result try_step( System &sys , state_type &x , time_type &t , time_type &dt )
+ controlled_step_result try_step( System system , state_type &x , time_type &t , time_type &dt )
{
if( m_dxdt_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() ) || m_first_call )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
sys( x , m_dxdt ,t );
m_first_call = false;
}
- return try_step( sys , x , m_dxdt , t , dt );
+ return try_step( system , x , m_dxdt , t , dt );
}
// try_step( sys , in , t , out , dt );
template< class System >
- controlled_step_result try_step( System &sys , const state_type &in , time_type &t , state_type &out , time_type &dt )
+ controlled_step_result try_step( System system , const state_type &in , time_type &t , state_type &out , time_type &dt )
{
if( m_dxdt_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() ) || m_first_call )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
sys( in , m_dxdt ,t );
m_first_call = false;
}
- return try_step( sys , in , m_dxdt , t , out , dt );
+ return try_step( system , in , m_dxdt , t , out , dt );
}
// try_step( sys , x , dxdt , t , dt )
template< class System >
- controlled_step_result try_step( System &sys , state_type &x , state_type &dxdt , time_type &t , time_type &dt )
+ controlled_step_result try_step( System system , state_type &x , state_type &dxdt , time_type &t , time_type &dt )
{
m_new_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
- controlled_step_result res = try_step( sys , x , dxdt , t , m_xnew , m_dxdtnew , dt );
+ controlled_step_result res = try_step( system , x , dxdt , t , m_xnew , m_dxdtnew , dt );
if( ( res == success_step_size_increased ) || ( res == success_step_size_unchanged) )
{
boost::numeric::odeint::copy( m_xnew , x );
@@ -313,7 +318,7 @@
// try_step( sys , in , dxdt , t , out , dt )
template< class System >
- controlled_step_result try_step( System &sys , const state_type &in , const state_type &dxdt_in , time_type &t ,
+ controlled_step_result try_step( System system , const state_type &in , const state_type &dxdt_in , time_type &t ,
state_type &out , state_type &dxdt_out , time_type &dt )
{
using std::max;
@@ -324,7 +329,7 @@
//fsal: m_stepper.get_dxdt( dxdt );
//fsal: m_stepper.do_step( sys , x , dxdt , t , dt , m_x_err );
- m_stepper.do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , m_xerr );
+ m_stepper.do_step( system , in , dxdt_in , t , out , dxdt_out , dt , m_xerr );
// this potentially overwrites m_x_err! (standard_error_checker does, at least)
time_type max_rel_err = m_error_checker.error( in , dxdt_in , m_xerr , dt );
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_dopri5.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_dopri5.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_dopri5.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -23,6 +23,7 @@
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/stepper/explicit_error_dopri5.hpp>
@@ -92,13 +93,14 @@
}
template< class System >
- std::pair< time_type , time_type > do_step( System &system )
+ std::pair< time_type , time_type > do_step( System system )
{
const size_t max_count = 1000;
if( !m_is_deriv_initialized )
{
- system( *m_current_state , *m_current_deriv , m_t );
+ typename boost::unwrap_reference< System >::type &sys = system;
+ sys( *m_current_state , *m_current_deriv , m_t );
m_is_deriv_initialized = true;
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_explicit_euler.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_explicit_euler.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/dense_output_explicit_euler.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -68,7 +68,7 @@
template< class System >
- std::pair< time_type , time_type > do_step( System &system )
+ std::pair< time_type , time_type > do_step( System system )
{
m_euler.do_step( system , *m_current_state , m_t , *m_old_state , m_dt );
m_t_old = m_t;
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_dopri5.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_dopri5.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_dopri5.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -12,6 +12,8 @@
#ifndef BOOST_BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_DOPRI5_HPP_INCLUDED
#define BOOST_BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_DOPRI5_HPP_INCLUDED
+#include <boost/ref.hpp>
+
#include <boost/numeric/odeint/algebra/standard_algebra.hpp>
#include <boost/numeric/odeint/algebra/standard_operations.hpp>
#include <boost/numeric/odeint/algebra/standard_resize.hpp>
@@ -84,8 +86,6 @@
void do_step_impl( System system , const state_type &in , const state_type &dxdt_in , const time_type t ,
state_type &out , state_type &dxdt_out , const time_type dt )
{
- m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
-
const time_type a2 = static_cast<time_type> ( 0.2 );
const time_type a3 = static_cast<time_type> ( 0.3 );
const time_type a4 = static_cast<time_type> ( 0.8 );
@@ -117,34 +117,38 @@
const time_type c5 = static_cast<time_type> ( -2187.0 ) / static_cast<time_type>( 6784.0 );
const time_type c6 = static_cast<time_type> ( 11.0 ) / static_cast<time_type>( 84.0 );
+ m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
+
+ typename boost::unwrap_reference< System >::type &sys = system;
+
//m_x1 = x + dt*b21*dxdt
algebra_type::for_each3( m_x1 , in , dxdt_in ,
typename operations_type::scale_sum2( 1.0 , dt*b21 ) );
- system( m_x1 , m_x2 , t + dt*a2 );
+ sys( m_x1 , m_x2 , t + dt*a2 );
// m_x1 = x + dt*b31*dxdt + dt*b32*m_x2
algebra_type::for_each4( m_x1 , in , dxdt_in , m_x2 ,
typename operations_type::scale_sum3( 1.0 , dt*b31 , dt*b32 ));
- system( m_x1 , m_x3 , t + dt*a3 );
+ sys( m_x1 , m_x3 , t + dt*a3 );
// m_x1 = x + dt * (b41*dxdt + b42*m_x2 + b43*m_x3)
algebra_type::for_each5( m_x1 , in , dxdt_in , m_x2 , m_x3 ,
typename operations_type::scale_sum4( 1.0 , dt*b41 , dt*b42 , dt*b43 ));
- system( m_x1, m_x4 , t + dt*a4 );
+ sys( m_x1, m_x4 , t + dt*a4 );
algebra_type::for_each6( m_x1 , in , dxdt_in , m_x2 , m_x3 , m_x4 ,
typename operations_type::scale_sum5( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 ));
- system( m_x1 , m_x5 , t + dt*a5 );
+ sys( m_x1 , m_x5 , t + dt*a5 );
algebra_type::for_each7( m_x1 , in , dxdt_in , m_x2 , m_x3 , m_x4 , m_x5 ,
typename operations_type::scale_sum6( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 ));
- system( m_x1 , m_x6 , t + dt );
+ sys( m_x1 , m_x6 , t + dt );
algebra_type::for_each7( out , in , dxdt_in , m_x3 , m_x4 , m_x5 , m_x6 ,
typename operations_type::scale_sum6( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c5 , dt*c6 ));
// the new derivative
- system( out , dxdt_out , t + dt );
+ sys( out , dxdt_out , t + dt );
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_rk54_ck.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_rk54_ck.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_error_rk54_ck.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -13,6 +13,7 @@
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_RK54_CK_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_RK54_CK_HPP_INCLUDED
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/algebra/standard_algebra.hpp>
#include <boost/numeric/odeint/algebra/standard_operations.hpp>
@@ -82,7 +83,6 @@
template< class System >
void do_step_impl( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt , state_type &xerr )
{
-
const time_type c1 = static_cast<time_type> ( 37.0 ) / static_cast<time_type>( 378.0 );
const time_type c3 = static_cast<time_type> ( 250.0 ) / static_cast<time_type>( 621.0 );
const time_type c4 = static_cast<time_type> ( 125.0 ) / static_cast<time_type>( 594.0 );
@@ -107,8 +107,6 @@
template< class System >
void do_step_impl( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
{
- m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
-
const time_type a2 = static_cast<time_type> ( 0.2 );
const time_type a3 = static_cast<time_type> ( 0.3 );
const time_type a4 = static_cast<time_type> ( 0.6 );
@@ -136,29 +134,33 @@
const time_type c4 = static_cast<time_type> ( 125.0 ) / static_cast<time_type>( 594.0 );
const time_type c6 = static_cast<time_type> ( 512.0 ) / static_cast<time_type>( 1771.0 );
+ m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
+
+ typename boost::unwrap_reference< System >::type &sys = system;
+
//m_x1 = x + dt*b21*dxdt
algebra_type::for_each3( m_x1 , in , dxdt ,
typename operations_type::scale_sum2( 1.0 , dt*b21 ) );
- system( m_x1 , m_x2 , t + dt*a2 );
+ sys( m_x1 , m_x2 , t + dt*a2 );
// m_x1 = x + dt*b31*dxdt + dt*b32*m_x2
algebra_type::for_each4( m_x1 , in , dxdt , m_x2 ,
typename operations_type::scale_sum3( 1.0 , dt*b31 , dt*b32 ));
- system( m_x1 , m_x3 , t + dt*a3 );
+ sys( m_x1 , m_x3 , t + dt*a3 );
// m_x1 = x + dt * (b41*dxdt + b42*m_x2 + b43*m_x3)
algebra_type::for_each5( m_x1 , in , dxdt , m_x2 , m_x3 ,
typename operations_type::scale_sum4( 1.0 , dt*b41 , dt*b42 , dt*b43 ));
- system( m_x1, m_x4 , t + dt*a4 );
+ sys( m_x1, m_x4 , t + dt*a4 );
algebra_type::for_each6( m_x1 , in , dxdt , m_x2 , m_x3 , m_x4 ,
typename operations_type::scale_sum5( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 ));
- system( m_x1 , m_x5 , t + dt*a5 );
+ sys( m_x1 , m_x5 , t + dt*a5 );
algebra_type::for_each7( m_x1 , in , dxdt , m_x2 , m_x3 , m_x4 , m_x5 ,
typename operations_type::scale_sum6( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 ));
- system( m_x1 , m_x6 , t + dt*a6 );
+ sys( m_x1 , m_x6 , t + dt*a6 );
algebra_type::for_each6( out , in , dxdt , m_x3 , m_x4 , m_x6 ,
typename operations_type::scale_sum5( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c6 ));
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_euler.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_euler.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_euler.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -45,7 +45,7 @@
BOOST_ODEINT_EXPLICIT_STEPPERS_TYPEDEFS( explicit_euler , 1 );
template< class System >
- void do_step_impl( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type & out , const time_type dt )
+ void do_step_impl( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type & out , const time_type dt )
{
algebra_type::for_each3( out , in , dxdt , typename operations_type::scale_sum2( 1.0 , dt ) );
}
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_rk4.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_rk4.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/explicit_rk4.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -13,6 +13,7 @@
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_RK4_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_RK4_HPP_INCLUDED
+#include <boost/ref.hpp>
#include <boost/numeric/odeint/algebra/standard_algebra.hpp>
#include <boost/numeric/odeint/algebra/standard_operations.hpp>
@@ -65,13 +66,16 @@
}
template< class System >
- void do_step_impl( System &system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
+ void do_step_impl( System system , const state_type &in , const state_type &dxdt , const time_type t , state_type &out , const time_type dt )
{
- m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
// ToDo : check if size of in,dxdt,out are equal?
const time_type val1 = static_cast<time_type>( 1.0 );
+ m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
+
+ typename boost::unwrap_reference< System >::type &sys = system;
+
time_type dh = static_cast<time_type>( 0.5 ) * dt;
time_type th = t + dh;
@@ -81,20 +85,20 @@
// dt * m_dxt = k2
- system( m_xt , m_dxt , th );
+ sys( m_xt , m_dxt , th );
// m_xt = x + dh*m_dxt
algebra_type::for_each3( m_xt , in , m_dxt , typename operations_type::scale_sum2( val1 , dh ) );
// dt * m_dxm = k3
- system( m_xt , m_dxm , th );
+ sys( m_xt , m_dxm , th );
//m_xt = x + dt*m_dxm
algebra_type::for_each3( m_xt , in , m_dxm , typename operations_type::scale_sum2( val1 , dt ) );
// dt * m_dxh = k4
- system( m_xt , m_dxh , t + dt );
+ sys( m_xt , m_dxh , t + dt );
//x += dt/6 * ( m_dxdt + m_dxt + val2*m_dxm )
time_type dt6 = dt / static_cast<time_type>( 6.0 );
time_type dt3 = dt / static_cast<time_type>( 3.0 );
Modified: sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/implicit_euler.hpp
==============================================================================
--- sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/implicit_euler.hpp (original)
+++ sandbox/odeint/branches/karsten/boost/numeric/odeint/stepper/implicit_euler.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -36,8 +36,11 @@
{ }
template< class System , class Jacobi >
- void do_step( System &system , Jacobi &jacobi , state_type &x , value_type t , value_type dt )
+ void do_step( System system , Jacobi jacobi , state_type &x , value_type t , value_type dt )
{
+ typename boost::unwrap_reference< System >::type &sys = system;
+ typename boost::unwrap_reference< Jacobi >::type &jac = jacobi;
+
m_dxdt.resize( x.size() );
m_x.resize( x.size() );
m_b.resize( x.size() );
@@ -47,11 +50,11 @@
t += dt;
// apply first Newton step
- system( x , m_dxdt , t );
+ sys( x , m_dxdt , t );
m_b = dt * m_dxdt;
- jacobi( x , m_jacobi , t );
+ jac( x , m_jacobi , t );
m_jacobi *= dt;
m_jacobi -= boost::numeric::ublas::identity_matrix< value_type >( x.size() );
@@ -65,7 +68,7 @@
// ToDo: maybe we should apply only one Newton step -> linear implicit one-step scheme
while( boost::numeric::ublas::norm_2( m_b ) > m_epsilon )
{
- system( m_x , m_dxdt , t );
+ sys( m_x , m_dxdt , t );
m_b = x - m_x + dt*m_dxdt;
/* we use simplified newton where the jacobi matrix is evaluated only once
Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/odeint_ref_problem.cpp
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/odeint_ref_problem.cpp (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/odeint_ref_problem.cpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -76,7 +76,7 @@
template< class System >
void do_step( System system , state_type &x , value_type t , value_type dt )
{
- typename boost::unwrap_reference< System >::type sys = system;
+ typename boost::unwrap_reference< System >::type &sys = system;
sys( x , m_dxdt , t );
// x = x + dt*dxdt
boost::numeric::odeint::detail::it_algebra::increment(
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/Jamfile
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/Jamfile 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,21 @@
+# (C) Copyright 2010 : Karsten Ahnert, 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)
+
+import os ;
+import modules ;
+import path ;
+
+path-constant HOME : [ os.environ HOME ] ;
+path-constant CHRONO_ROOT : [ os.environ CHRONO_ROOT ] ;
+
+project
+ : requirements
+ <define>BOOST_ALL_NO_LIB=1
+ <include>../../../../..
+ <include>$(BOOST_ROOT)
+ ;
+
+exe test_units
+ : test_units.cpp
+ ;
\ No newline at end of file
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/adjust_size_units.hpp
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/adjust_size_units.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,197 @@
+/*
+ boost header: NUMERIC_ODEINT/adjust_size.hpp
+
+ Copyright 2009 Karsten Ahnert
+ Copyright 2009 Mario Mulansky
+ Copyright 2009 Andre Bergner
+
+ 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_ADJUST_SIZE_UNITS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ADJUST_SIZE_UNITS_HPP_INCLUDED
+
+#include <algorithm>
+
+#include <boost/noncopyable.hpp>
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/algebra/standard_resize.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+/*
+ * Tags to specify resize behavior of steppers
+ */
+struct adjust_size_manually_tag {};
+struct adjust_size_initially_tag {};
+struct adjust_size_always_tag {};
+
+
+
+
+
+
+/*
+ * Adjust size functionality with policies and resizeability
+ */
+template< class Deriv , size_t Dim >
+class size_adjuster_units : boost::noncopyable
+{
+public:
+
+ size_adjuster_units() : m_is_initialized( false ) , m_states()
+ {
+ std::fill( m_states.begin() , m_states.end() , static_cast< Deriv* >( 0 ) );
+ }
+
+ template< class State >
+ bool adjust_size( const State &x )
+ {
+ return adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+ }
+
+ template< class State >
+ bool adjust_size_by_policy( const State &x , adjust_size_manually_tag )
+ {
+ return false;
+ }
+
+ template< class State >
+ bool adjust_size_by_policy( const State &x , adjust_size_initially_tag )
+ {
+ if( !m_is_initialized )
+ {
+ m_is_initialized = true;
+ return adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ template< class State >
+ bool adjust_size_by_policy( const State &x , adjust_size_always_tag )
+ {
+ return adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+ }
+
+ void register_state( size_t idx , Deriv &x )
+ {
+ m_states[idx] = &x;
+ }
+
+
+private:
+
+ template< class State >
+ bool adjust_size_by_resizeability( const State &x , boost::true_type )
+ {
+ bool changed = ( Dim > 0 );
+ for( size_t i=0 ; i<Dim ; ++i )
+ {
+ boost::numeric::odeint::adjust_size( x , *(m_states[i]) );
+ }
+ return changed;
+ }
+
+ template< class State >
+ bool adjust_size_by_resizeability( const State &x , boost::false_type )
+ {
+ return false;
+ }
+
+
+private :
+
+ bool m_is_initialized;
+ boost::array< Deriv* , Dim > m_states;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * really old stuff
+ */
+//template< class State , class AdjustSizeImpl >
+//class size_adjuster
+//{
+//public:
+//
+// size_adjuster( AdjustSizeImpl &adjust_size_impl ) : m_is_initialized( false ) , m_adjust_size_impl( adjust_size_impl ) { }
+//
+// void adjust_size( const State &x )
+// {
+// adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+// }
+//
+// void adjust_size_by_policy( const State &x , adjust_size_manually_tag )
+// {
+// }
+//
+// void adjust_size_by_policy( const State &x , adjust_size_initially_tag )
+// {
+// if( !m_is_initialized )
+// {
+// adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+// m_is_initialized = true;
+// }
+// }
+//
+// void adjust_size_by_policy( const State &x , adjust_size_always_tag )
+// {
+// adjust_size_by_resizeability( x , typename is_resizeable< State >::type() );
+// }
+//
+//
+//private:
+//
+//
+// void adjust_size_by_resizeability( const State &x , boost::true_type )
+// {
+// m_adjust_size_impl( x );
+// }
+//
+// void adjust_size_by_resizeability( const State &x , boost::false_type )
+// {
+// }
+//
+//
+//private :
+//
+// bool m_is_initialized;
+// AdjustSizeImpl &m_adjust_size_impl;
+//};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif //BOOST_NUMERIC_ODEINT_ADJUST_SIZE_UNITS_HPP_INCLUDED
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_euler_units.hpp
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_euler_units.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,67 @@
+/*
+ boost header: BOOST_NUMERIC_ODEINT/explicit_euler.hpp
+
+ Copyright 2009 Karsten Ahnert
+ Copyright 2009 Mario Mulansky
+ Copyright 2009 Andre Bergner
+
+ 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_BOOST_NUMERIC_ODEINT_EXPLICIT_EULER_UNITS_HPP_INCLUDED
+#define BOOST_BOOST_NUMERIC_ODEINT_EXPLICIT_EULER_UNITS_HPP_INCLUDED
+
+#include <boost/numeric/odeint/algebra/standard_algebra.hpp>
+
+#include "explicit_stepper_base_units.hpp"
+#include "standard_operations_units.hpp"
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<
+ class Deriv ,
+ class Value = double ,
+ class Time = double ,
+ class Algebra = standard_algebra ,
+ class Operations = standard_operations_units ,
+ class AdjustSizePolicy = adjust_size_initially_tag
+ >
+class explicit_euler_units
+: public explicit_stepper_base_units<
+ explicit_euler_units< Deriv , Value , Time , Algebra , Operations , AdjustSizePolicy > ,
+ 1 , Deriv , Value , Time , Algebra , Operations , AdjustSizePolicy >
+{
+public :
+
+ typedef explicit_stepper_base_units<
+ explicit_euler_units< Deriv , Value , Time , Algebra , Operations , AdjustSizePolicy > ,
+ 1 , Deriv , Value , Time , Algebra , Operations , AdjustSizePolicy > stepper_base_type;
+ typedef typename stepper_base_type::deriv_type deriv_type;
+ typedef typename stepper_base_type::value_type value_type;
+ typedef typename stepper_base_type::time_type time_type;
+ typedef typename stepper_base_type::algebra_type algebra_type;
+ typedef typename stepper_base_type::operations_type operations_type;
+ typedef typename stepper_base_type::adjust_size_policy adjust_size_policy;
+ typedef typename stepper_base_type::stepper_type stepper_type;
+
+
+ template< class System , class State >
+ void do_step_impl( System system , const State &in , const deriv_type &dxdt , const time_type t , State & out , const time_type dt )
+ {
+ algebra_type::for_each3( out , in , dxdt , operations_type::make_scale_sum2( static_cast< value_type >( 1.0 ) , dt ) );
+ }
+};
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif //BOOST_BOOST_NUMERIC_ODEINT_EXPLICIT_EULER_UNITS_HPP_INCLUDED
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_stepper_base_units.hpp
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/explicit_stepper_base_units.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,146 @@
+/*
+ boost header: numeric/odeint/explicit_stepper_base.hpp
+
+ Copyright 2009 Karsten Ahnert
+ Copyright 2009 Mario Mulansky
+ Copyright 2009 Andre Bergner
+
+ 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_EXPLICIT_STEPPER_BASE_UNITS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXPLICIT_STEPPER_BASE_UNITS_HPP_INCLUDED
+
+#include <boost/noncopyable.hpp>
+#include <boost/ref.hpp>
+
+#include <boost/numeric/odeint/algebra/standard_resize.hpp>
+
+#include "adjust_size_units.hpp"
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * base class for explicit steppers
+ * models the stepper concept
+ */
+template<
+ class Stepper ,
+ unsigned short Order ,
+ class Deriv ,
+ class Value ,
+ class Time ,
+ class Algebra ,
+ class Operations ,
+ class AdjustSizePolicy
+>
+class explicit_stepper_base_units : boost::noncopyable
+{
+public:
+
+
+ typedef Deriv deriv_type;
+ typedef Value value_type;
+ typedef Time time_type;
+ typedef Algebra algebra_type;
+ typedef Operations operations_type;
+ typedef AdjustSizePolicy adjust_size_policy;
+ typedef Stepper stepper_type;
+
+ typedef explicit_stepper_base_units< Stepper , Order , Deriv , Value , Time , Algebra , Operations , AdjustSizePolicy > internal_stepper_base_type;
+
+ typedef unsigned short order_type;
+ static const order_type order_value = Order;
+
+
+ order_type order( void ) const
+ {
+ return order_value;
+ }
+
+
+ explicit_stepper_base_units( void ) : m_size_adjuster() , m_dxdt()
+ {
+ boost::numeric::odeint::construct( m_dxdt );
+ m_size_adjuster.register_state( 0 , m_dxdt );
+ }
+
+ ~explicit_stepper_base_units( void )
+ {
+ boost::numeric::odeint::destruct( m_dxdt );
+ }
+
+
+
+
+ // do_step( sys , x , t , dt )
+ template< class System , class State >
+ void do_step( System system , State &x , const time_type &t , const time_type &dt )
+ {
+ typename boost::unwrap_reference< System >::type &sys = system;
+ m_size_adjuster.adjust_size_by_policy( x , adjust_size_policy() );
+ sys( x , m_dxdt ,t );
+ this->stepper().do_step_impl( system , x , m_dxdt , t , x , dt );
+ }
+
+ // do_step( sys , x , dxdt , t , dt )
+ template< class System , class State >
+ void do_step( System system , State &x , const deriv_type dxdt , const time_type &t , const time_type &dt )
+ {
+ this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
+ }
+
+ // do_step( sys , in , t , out , dt )
+ template< class System , class State >
+ void do_step( System system , const State &in , const time_type &t , State &out , const time_type &dt )
+ {
+ typename boost::unwrap_reference< System >::type &sys = system;
+ m_size_adjuster.adjust_size_by_policy( in , adjust_size_policy() );
+ sys( in , m_dxdt ,t );
+ this->stepper().do_step_impl( system , in , m_dxdt , t , out , dt );
+ }
+
+ // do_step( sys , in , dxdt , t , out , dt )
+ template< class System , class State >
+ void do_step( System system , const State &in , const deriv_type &dxdt , const time_type &t , State &out , const time_type &dt )
+ {
+ this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
+ }
+
+
+
+ template< class State >
+ void adjust_size( const State &x )
+ {
+ m_size_adjuster.adjust_size( x );
+ }
+
+
+protected:
+
+ stepper_type& stepper( void )
+ {
+ return *static_cast< stepper_type* >( this );
+ }
+
+ const stepper_type& stepper( void ) const
+ {
+ return *static_cast< const stepper_type* >( this );
+ }
+
+
+ size_adjuster_units< deriv_type , 1 > m_size_adjuster;
+ deriv_type m_dxdt;
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+#endif //BOOST_NUMERIC_ODEINT_EXPLICIT_STEPPER_BASE_UNITS_HPP_INCLUDED
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/standard_operations_units.hpp
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/standard_operations_units.hpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,55 @@
+/*
+ boost header: BOOST_NUMERIC_ODEINT/standard_operations.hpp
+
+ Copyright 2009 Karsten Ahnert
+ Copyright 2009 Mario Mulansky
+ Copyright 2009 Andre Bergner
+
+ 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_BOOST_NUMERIC_ODEINT_STANDARD_OPERATIONS_UNITS_HPP_INCLUDED
+#define BOOST_BOOST_NUMERIC_ODEINT_STANDARD_OPERATIONS_UNITS_HPP_INCLUDED
+
+#include <algorithm> // for std::max
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+struct standard_operations_units
+{
+ template< class Fac1 , class Fac2 >
+ struct scale_sum2
+ {
+ const Fac1 m_alpha1;
+ const Fac2 m_alpha2;
+
+ scale_sum2( const Fac1 &alpha1 , const Fac2 &alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
+
+ template< class T1 , class T2 , class T3 >
+ void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const
+ {
+ t1 = m_alpha1 * t2 + m_alpha2 * t3;
+ }
+ };
+
+ template< class Fac1 , class Fac2 >
+ scale_sum2< Fac1 , Fac2 > make_scale_sum2( const Fac1 &alpha1 , const Fac2 &alpha2 )
+ {
+ return scale_sum2< Fac1 , Fac2 >( alpha1 , alpha2 );
+ }
+
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif //BOOST_BOOST_NUMERIC_ODEINT_STANDARD_OPERATIONS_UNITS_HPP_INCLUDED
Added: sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/test_units.cpp
==============================================================================
--- (empty file)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/ideas/units/test_units.cpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,64 @@
+/*
+ * test.cpp
+ *
+ * Created on: Jan 18, 2011
+ * Author: karsten
+ */
+
+#include <iostream>
+#include <tr1/array>
+
+#include <boost/units/systems/si/energy.hpp>
+#include <boost/units/systems/si/force.hpp>
+#include <boost/units/systems/si/length.hpp>
+#include <boost/units/systems/si/time.hpp>
+#include <boost/units/systems/si/electric_potential.hpp>
+#include <boost/units/systems/si/current.hpp>
+#include <boost/units/systems/si/resistance.hpp>
+#include <boost/units/systems/si/io.hpp>
+
+#include "explicit_euler_units.hpp"
+
+namespace units = boost::units;
+namespace si = boost::units::si;
+
+using std::cout;
+using std::endl;
+
+typedef units::derived_dimension< units::length_base_dimension , 1 , units::time_base_dimension , -1 > vel_type;
+
+typedef std::tr1::array< units::quantity< si::length > , 2 > state_type;
+typedef std::tr1::array< units::quantity< vel_type > , 2 > deriv_type;
+typedef units::quantity< si::time > time_type;
+
+typedef boost::numeric::odeint::explicit_euler_units< deriv_type , double , time_type > stepper_type;
+
+struct lorenz
+{
+ template< class State , class Deriv , class Time >
+ void operator()( const State &x , Deriv &dxdt , const Time &t )
+ {
+ dxdt[0] = ( x[0] / Time( 1.0 * si::second ) );
+ dxdt[0] = ( x[1] / Time( 1.0 * si::second ) );
+ }
+};
+
+
+
+int main( int argc , char **argv )
+{
+ /*
+ * zwei faelle, erstens units, zweitens ranges
+ */
+ state_type x = {{ 1.0 * si::meter , 1.0 * si::meter }};
+ time_type t( 0.0 * si::seconds ) , dt( 0.0 * si::seconds );
+ stepper_type stepper;
+ stepper.do_step( lorenz() , x , t , dt );
+
+// units::quantity< si::length > x( 2.0 * si::meter );
+// units::quantity< si::time > t( 1.0 * si::second );
+
+// cout << x * t << endl;
+
+ return 0;
+}
Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/test/check_stepper_concepts.cpp
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/test/check_stepper_concepts.cpp (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/test/check_stepper_concepts.cpp 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -20,6 +20,7 @@
#include <iostream>
#include <tr1/array>
+#include <boost/ref.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/mpl/vector.hpp>
@@ -52,6 +53,8 @@
typedef vector_space_1d< double > vector_space_type;
typedef std::tr1::array< double , 1 > array_type;
+const double result = 2.2;
+
typedef mpl::vector< vector_type , vector_space_type , array_type >::type container_types;
@@ -59,6 +62,29 @@
template<> struct algebra_dispatcher< vector_space_type > { typedef vector_space_algebra type; };
template<> struct algebra_dispatcher< double > { typedef vector_space_algebra type; };
+struct constant_system_vector_class
+{
+ void operator()( const vector_type &x , vector_type &dxdt , double t ) const
+ {
+ dxdt[0] = 1.0;
+ }
+};
+
+struct constant_system_vector_space_class
+{
+ void operator()( const vector_space_type &x , vector_space_type &dxdt , double t ) const
+ {
+ dxdt.m_x = 1.0;
+ }
+};
+
+struct constant_system_array_class
+{
+ void operator()( const array_type &x , array_type &dxdt , double t ) const
+ {
+ dxdt[0] = 1.0;
+ }
+};
void constant_system_vector( const vector_type &x , vector_type &dxdt , double t ) { dxdt[0] = 1.0; }
void constant_system_vector_space( const vector_space_type &x , vector_space_type &dxdt , double t ) { dxdt.m_x = 1.0; }
@@ -115,7 +141,8 @@
vector_type x( 1 , 2.0 );
Stepper stepper;
check_stepper_concept( stepper , constant_system_vector , x );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_stepper_concept( stepper , boost::cref( constant_system_vector_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
@@ -128,7 +155,8 @@
x.m_x = 2.0;
Stepper stepper;
check_stepper_concept( stepper , constant_system_vector_space , x );
- BOOST_CHECK_SMALL( fabs( x.m_x - 2.1 ) , eps );
+ check_stepper_concept( stepper , boost::cref( constant_system_vector_space_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x.m_x - result ) , eps );
}
};
@@ -141,7 +169,8 @@
x[0] = 2.0;
Stepper stepper;
check_stepper_concept( stepper , constant_system_array , x );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_stepper_concept( stepper , boost::cref( constant_system_array_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
@@ -209,7 +238,8 @@
vector_type x( 1 , 2.0 ) , xerr( 1 );
Stepper stepper;
check_error_stepper_concept( stepper , constant_system_vector , x , xerr );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_error_stepper_concept( stepper , boost::cref( constant_system_vector_class() ) , x , xerr );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
@@ -223,7 +253,8 @@
x.m_x = 2.0;
Stepper stepper;
check_error_stepper_concept( stepper , constant_system_vector_space , x , xerr );
- BOOST_CHECK_SMALL( fabs( x.m_x - 2.1 ) , eps );
+ check_error_stepper_concept( stepper , boost::cref( constant_system_vector_space_class() ) , x , xerr );
+ BOOST_CHECK_SMALL( fabs( x.m_x - result ) , eps );
}
};
@@ -236,7 +267,8 @@
x[0] = 2.0;
Stepper stepper;
check_error_stepper_concept( stepper , constant_system_array , x , xerr );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_error_stepper_concept( stepper , boost::cref( constant_system_array_class() ) , x , xerr );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
@@ -303,7 +335,8 @@
error_checker_standard< typename ControlledStepper::state_type , typename ControlledStepper::time_type > error_checker;
ControlledStepper controlled_stepper( error_stepper , error_checker );
check_controlled_stepper_concept( controlled_stepper , constant_system_vector , x );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_controlled_stepper_concept( controlled_stepper , boost::cref( constant_system_vector_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
@@ -318,7 +351,8 @@
error_checker_standard< typename ControlledStepper::state_type , typename ControlledStepper::time_type , vector_space_algebra > error_checker;
ControlledStepper controlled_stepper( error_stepper , error_checker );
check_controlled_stepper_concept( controlled_stepper , constant_system_vector_space , x );
- BOOST_CHECK_SMALL( fabs( x.m_x - 2.1 ) , eps );
+ check_controlled_stepper_concept( controlled_stepper , boost::cref( constant_system_vector_space_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x.m_x - result ) , eps );
}
};
@@ -333,7 +367,8 @@
error_checker_standard< typename ControlledStepper::state_type , typename ControlledStepper::time_type > error_checker;
ControlledStepper controlled_stepper( error_stepper , error_checker );
check_controlled_stepper_concept( controlled_stepper , constant_system_array , x );
- BOOST_CHECK_SMALL( fabs( x[0] - 2.1 ) , eps );
+ check_controlled_stepper_concept( controlled_stepper , boost::cref( constant_system_array_class() ) , x );
+ BOOST_CHECK_SMALL( fabs( x[0] - result ) , eps );
}
};
Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/test/thrust/Makefile
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/test/thrust/Makefile (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/test/thrust/Makefile 2011-01-18 08:14:20 EST (Tue, 18 Jan 2011)
@@ -6,7 +6,7 @@
INCLUDES += -I$(BOOST_ROOT) -I$(THRUST_ROOT) -I$(CUDA_ROOT)/include -I../../../../..
-NVCCFLAGS = -O3 $(INCLUDES) --compiler-bindir=/usr/bin/g++-4.3
+NVCCFLAGS = -O3 $(INCLUDES) --compiler-bindir=/usr/bin/g++-4.4
LDLIBS = -lcudart
LDFLAGS = -L$(CUDA_ROOT)/lib64
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk