/*
* const_step_iterator.cpp
*
* Copyright 2012-2013 Karsten Ahnert
* Copyright 2013 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)
*
* several examples for using iterators
*/
#include <iostream>
#include <iterator>
#include <utility>
#include <algorithm>
#include <array>
#include <cassert>
#include <boost/range/algorithm.hpp>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/numeric.hpp>
#include <boost/numeric/odeint/stepper/runge_kutta4.hpp>
#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
#include <boost/numeric/odeint/stepper/generation.hpp>
#include <boost/numeric/odeint/iterator/const_step_iterator.hpp>
#include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp>
#define tab "\t"
using namespace std;
using namespace boost::numeric::odeint;
const double sigma = 10.0;
const double R = 28.0;
const double b = 8.0 / 3.0;
struct lorenz
{
template< class State , class Deriv >
void operator()( const State &x , Deriv &dxdt , double t ) const
{
dxdt[0] = sigma * ( x[1] - x[0] );
dxdt[1] = R * x[0] - x[1] - x[0] * x[2];
dxdt[2] = -b * x[2] + x[0] * x[1];
}
};
int main( int argc , char **argv )
{
typedef std::array< double , 3 > state_type;
// std::for_each
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
std::for_each( make_const_step_time_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
make_const_step_time_iterator_end( stepper , lorenz() , x ) ,
[]( const std::pair< const state_type&, double > &x ) {
std::cout << x.second << tab << x.first[0] << tab << x.first[1] << tab << x.first[2] << "\n"; } );
}
// std::copy_if
{
std::vector< state_type > res;
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
std::copy_if( make_const_step_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
make_const_step_iterator_end( stepper , lorenz() , x ) ,
std::back_inserter( res ) ,
[]( const state_type& x ) {
return ( x[0] > 0.0 ) ? true : false; } );
for( size_t i=0 ; i<res.size() ; ++i )
cout << res[i][0] << tab << res[i][1] << tab << res[i][2] << "\n";
}
// std::accumulate
{
//[ const_step_iterator_accumulate
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = std::accumulate( make_const_step_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
make_const_step_iterator_end( stepper , lorenz() , x ) ,
0.0 ,
[]( double sum , const state_type &x ) {
return sum + x[0]; } );
cout << res << endl;
//]
}
// std::transform
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
vector< double > weights;
std::transform( make_const_step_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
make_const_step_iterator_end( stepper , lorenz() , x ) ,
back_inserter( weights ) ,
[]( const state_type &x ) {
return sqrt( x[0] * x[0] + x[1] * x[1] + x[2] * x[2] ); } );
for( size_t i=0 ; i<weights.size() ; ++i )
cout << weights[i] << "\n";
}
// std::transform with time_iterator
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
vector< double > weights;
std::transform( make_const_step_time_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
make_const_step_time_iterator_end( stepper , lorenz() , x ) ,
back_inserter( weights ) ,
[]( const std::pair< const state_type &, double > &x ) {
return sqrt( x.first[0] * x.first[0] + x.first[1] * x.first[1] + x.first[2] * x.first[2] ); } );
for( size_t i=0 ; i<weights.size() ; ++i )
cout << weights[i] << "\n";
}
// /*
// * Boost.Range versions
// */
// boost::range::for_each
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
boost::range::for_each( make_const_step_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
[]( const state_type &x ) {
std::cout << x[0] << tab << x[1] << tab << x[2] << "\n"; } );
}
// boost::range::for_each with time iterator
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
boost::range::for_each( make_const_step_time_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
[]( const std::pair< const state_type& , double > &x ) {
std::cout << x.second << tab << x.first[0] << tab << x.first[1] << tab << x.first[2] << "\n"; } );
}
// boost::range::copy with filtered adaptor (simulating std::copy_if)
{
std::vector< state_type > res;
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
boost::range::copy( make_const_step_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) |
boost::adaptors::filtered( [] ( const state_type &x ) { return ( x[0] > 0.0 ); } ) ,
std::back_inserter( res ) );
for( size_t i=0 ; i<res.size() ; ++i )
cout << res[i][0] << tab << res[i][1] << tab << res[i][2] << "\n";
}
// boost::range::accumulate
{
//[const_step_iterator_accumulate_range
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_const_step_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
[]( double sum , const state_type &x ) {
return sum + x[0]; } );
cout << res << endl;
//]
}
// boost::range::accumulate with time iterator
{
//[const_step_time_iterator_accumulate_range
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_const_step_time_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
[]( double sum , const std::pair< const state_type &, double > &x ) {
return sum + x.first[0]; } );
cout << res << endl;
//]
}
// boost::range::transform
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
vector< double > weights;
boost::transform( make_const_step_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , back_inserter( weights ) ,
[]( const state_type &x ) {
return sqrt( x[0] * x[0] + x[1] * x[1] + x[2] * x[2] ); } );
for( size_t i=0 ; i<weights.size() ; ++i )
cout << weights[i] << "\n";
}
// boost::range::find with time iterator
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
auto iter = boost::find_if( make_const_step_time_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
[]( const std::pair< const state_type & , double > &x ) {
return ( x.first[0] < 0.0 ); } );
cout << iter->second << "\t" << iter->first[0] << "\t" << iter->first[1] << "\t" << iter->first[2] << "\n";
}
/*
* Boost.Range versions for dense output steppers
*/
// boost::range::for_each
{
runge_kutta_dopri5< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
boost::range::for_each( make_const_step_range( make_dense_output( 1.0e-6 , 1.0e-6 , stepper ) , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
[]( const state_type &x ) {
std::cout << x[0] << tab << x[1] << tab << x[2] << "\n"; } );
}
// boost::range::for_each with time iterator
{
runge_kutta_dopri5< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
boost::range::for_each( make_const_step_time_range( make_dense_output( 1.0e-6 , 1.0e-6 , stepper ) , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
[]( const std::pair< const state_type& , double > &x ) {
std::cout << x.second << tab << x.first[0] << tab << x.first[1] << tab << x.first[2] << "\n"; } );
}
/*
* Pure iterators
*/
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
auto first = make_const_step_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 );
auto last = make_const_step_iterator_end( stepper , lorenz() , x );
while( first != last )
{
assert( last != first );
cout << (*first)[0] << tab << (*first)[1] << tab << (*first)[2] << "\n";
++first;
}
}
{
runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
auto first = make_const_step_time_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 );
auto last = make_const_step_time_iterator_end( stepper , lorenz() , x );
while( first != last )
{
assert( last != first );
cout << first->second << tab << first->first[0] << tab << first->first[1] << tab << first->first[2] << "\n";
++first;
}
}
return 0;
}
