void operator()( void )
{
Stepper stepper;
const int o = stepper.order()+1; //order of the error is order of approximation + 1
const state_type x0 = {{ 0.0 , 1.0 }};
state_type x1;
const double t = 0.0;
/* do a first step with dt=0.1 to get an estimate on the prefactor of the error dx = f * dt^(order+1) */
double dt = 0.5;
stepper.do_step( osc() , x0 , t , x1 , dt );
const double f = 2.0 * std::abs( sin(dt) - x1[0] ) / std::pow( dt , o ); // upper bound
std::cout << o << " , " << f << std::endl;
/* as long as we have errors above machine precision */
while( f*std::pow( dt , o ) > 1E-16 )
{
// reset stepper which require resetting (fsal steppers)
resetter< typename Stepper::stepper_category >::reset( stepper );
stepper.do_step( osc() , x0 , t , x1 , dt );
std::cout << "Testing dt=" << dt << std::endl;
BOOST_CHECK_LT( std::abs( sin(dt) - x1[0] ) , f*std::pow( dt , o ) );
dt *= 0.5;
}
}
void run( Stepper &stepper , const size_t num_of_steps = 20000000 , const double dt = 1E-10 )
{
const size_t loops = 20;
accumulator_type acc;
timer_type timer;
srand( 12312354 );
// transient
//stepper.reset_init_cond( );
//for( size_t i = 0 ; i < num_of_steps ; ++i )
// stepper.do_step( dt );
for( size_t n=0 ; n<loops+1 ; ++n )
{
stepper.reset_init_cond( );
timer.restart();
for( size_t i = 0 ; i < num_of_steps ; ++i )
stepper.do_step( dt );
if( n>0 )
{ // take first run as transient
acc(timer.elapsed());
clog.precision(8);
clog.width(10);
clog << acc << " " << stepper.state(0) << endl;
}
}
cout << acc << endl;
}
void check_stepper( Stepper &stepper )
{
typedef Stepper stepper_type;
typedef typename stepper_type::state_type state_type;
typedef typename stepper_type::value_type value_type;
typedef typename stepper_type::deriv_type deriv_type;
typedef typename stepper_type::time_type time_type;
typedef typename stepper_type::order_type order_type;
typedef typename stepper_type::algebra_type algebra_type;
typedef typename stepper_type::operations_type operations_type;
const time_type t( 0.0 * si::second );
time_type dt( 0.1 * si::second );
state_type x( 1.0 * si::meter , 0.0 * si::meter_per_second );
// test call method one
stepper.do_step( oscillator , x , t , dt );
// test call method two
stepper.do_step( oscillator , x , t , x , dt );
// test call method three
deriv_type dxdt;
oscillator( x , dxdt , t );
stepper.do_step( oscillator , x , dxdt , t , dt );
// test call method four
oscillator( x , dxdt , t );
stepper.do_step( oscillator , x , dxdt , t , x , dt );
}
void operator()( void )
{
Stepper stepper;
const int o = stepper.order()+1; //order of the error is order of approximation + 1
const state_type q0 = {{ 0.0 }};
const state_type p0 = {{ 1.0 }};
state_type q1,p1;
std::pair< state_type , state_type >x1( q1 , p1 );
const double t = 0.0;
/* do a first step with dt=0.1 to get an estimate on the prefactor of the error dx = f * dt^(order+1) */
double dt = 0.5;
stepper.do_step( osc() , std::make_pair( q0 , p0 ) , t , x1 , dt );
const double f = 2.0 * std::abs( sin(dt) - x1.first[0] ) / std::pow( dt , o );
std::cout << o << " , " << f << std::endl;
/* as long as we have errors above machine precision */
while( f*std::pow( dt , o ) > 1E-16 )
{
stepper.do_step( osc() , std::make_pair( q0 , p0 ) , t , x1 , dt );
std::cout << "Testing dt=" << dt << std::endl;
BOOST_CHECK_SMALL( std::abs( sin(dt) - x1.first[0] ) , f*std::pow( dt , o ) );
dt *= 0.5;
}
}
void check_error_stepper_concept( Stepper &stepper , System system , typename Stepper::state_type &x , typename Stepper::state_type &xerr )
{
typedef Stepper stepper_type;
typedef typename stepper_type::deriv_type container_type;
typedef typename stepper_type::order_type order_type;
typedef typename stepper_type::time_type time_type;
stepper.do_step( system , x , static_cast<time_type>(0.0) , static_cast<time_type>(0.1) );
stepper.do_step( system , x , static_cast<time_type>(0.0) , static_cast<time_type>(0.1) , xerr );
}
void check_error_stepper_concept( Stepper &stepper , System system , typename Stepper::state_type &x , typename Stepper::state_type &xerr )
{
typedef Stepper stepper_type;
typedef typename stepper_type::deriv_type container_type;
typedef typename stepper_type::order_type order_type;
typedef typename stepper_type::time_type time_type;
stepper.do_step( system , typename boost::add_reference< container_type>::type( x ), 0.0 , 0.1 );
stepper.do_step( system , typename boost::add_reference< container_type>::type( x ), 0.0 , 0.1 , typename boost::add_reference< container_type>::type( xerr ) );
}
void addStepper(){
_MOTOR1_EN = 0;
_MOTOR2_EN = 0;
_STEPPER_EN = 1;
pinMode(SLIDESW1_D1,INPUT);
pinMode(SLIDESW1_D2,INPUT);
pinMode(TACTILESW1, INPUT);
pinMode(TACTILESW2, INPUT);
stepper.attachStepper(stepsPerRevolution, STEPPER_D1, STEPPER_D2,
STEPPER_D3, STEPPER_D4);
stepper.setSpeed(60);
actionAdd(controlStepper, 1);
}
void operator()( void )
{
double t = 0;
const double dt = 0.1;
state_type x = 0;
Stepper stepper;
InitStepper init_stepper;
stepper.initialize( init_stepper, rhs, x, t, dt );
// ab-stepper needs order-1 init steps: t and x should be (order-1)*dt
BOOST_CHECK_CLOSE( t , (stepper.order()-1)*dt , 1E-16 );
BOOST_CHECK_CLOSE( x, ( stepper.order() - 1 ) * dt, 2E-14 );
}
size_t integrate_adaptive(
Stepper stepper , System system , State &start_state ,
Time &start_time , Time end_time , Time &dt ,
Observer observer , controlled_stepper_tag
)
{
typename omplext_odeint::unwrap_reference< Observer >::type &obs = observer;
const size_t max_attempts = 1000;
const char *error_string = "Integrate adaptive : Maximal number of iterations reached. A step size could not be found.";
size_t count = 0;
while( less_with_sign( start_time , end_time , dt ) )
{
obs( start_state , start_time );
if( less_with_sign( end_time , start_time + dt , dt ) )
{
dt = end_time - start_time;
}
size_t trials = 0;
controlled_step_result res = success;
do
{
res = stepper.try_step( system , start_state , start_time , dt );
++trials;
}
while( ( res == fail ) && ( trials < max_attempts ) );
if( trials == max_attempts ) throw std::overflow_error( error_string );
++count;
}
obs( start_state , start_time );
return count;
}
//This is a basic operation
bool process(Direction direction, Stepper &sm)
{
switch (direction)
{
case Forward:
sm.changeState(state + step);
break;
case Backward:
sm.changeState(state - step);
break;
default:
return false;
break;
}
return true;
}
void setup()
{
Serial.begin(9600);
stepper.setSpeed(30);
}
void loop()
{
val=encoder/faktor;
if (val < minimum)
{val=minimum;
encoder=minimum*faktor;}
if (val > maximum)
{val=maximum;
encoder=maximum*faktor;}
if (val !=val_old)
{
// Serial.print (encoder);
// Serial.print (" ");
// Serial.print (val);
// Serial.print (" ");
val_old=val;
sprintf(buffer,"%3d",val);
digitalWrite(stepper_enable, LOW);
lcd.setCursor(10, 2);
lcd.print(buffer);
//lcd.cursorTo(1, 10);
// lcd.printIn(buffer);
stepper.step(100);
}
digitalWrite(stepper_enable, HIGH);
if (abs (val - stepper_position) >10)
{ lcd.setCursor(19, 3);
lcd.blink();}
stepper.step(val - stepper_position);
lcd.noBlink();
digitalWrite(stepper_enable, LOW);
stepper_position=val;
}
/*!
Returns propagated state and max relative errors in
kinetic energy and magnetic moment of particle.
*/
template<class Stepper> std::tuple<state_t, double, double> trace_trajectory(
state_t state,
const double time_step
) {
using std::fabs;
using std::max;
constexpr double propagation_time = 424.1; // seconds, 1/100 of doi above
Particle_Propagator propagator(proton_charge_mass_ratio);
const double
initial_energy = 0.5 * proton_mass * state[1].squaredNorm(),
initial_magnetic_moment
= proton_mass
* std::pow(state[1][1], 2)
/ (2 * get_earth_dipole(state[0]).norm());
Stepper stepper;
double nrj_error = 0, mom_error = 0;
for (double time = 0; time < propagation_time; time += time_step) {
stepper.do_step(propagator, state, time, time_step);
const Eigen::Vector3d
v(state[1]),
b(get_earth_dipole(state[0])),
v_perp_b(v - (v.dot(b) / b.squaredNorm()) * b);
const double
current_energy
= 0.5 * proton_mass * state[1].squaredNorm(),
current_magnetic_moment
= proton_mass * v_perp_b.squaredNorm() / (2 * b.norm());
nrj_error = max(
nrj_error,
fabs(current_energy - initial_energy) / initial_energy
);
mom_error = max(
mom_error,
fabs(current_magnetic_moment - initial_magnetic_moment)
/ initial_magnetic_moment
);
}
return std::make_tuple(state, nrj_error, mom_error);
}
void check_dense_output_stepper( Stepper &stepper )
{
typedef Stepper stepper_type;
typedef typename stepper_type::state_type state_type;
typedef typename stepper_type::value_type value_type;
typedef typename stepper_type::deriv_type deriv_type;
typedef typename stepper_type::time_type time_type;
// typedef typename stepper_type::order_type order_type;
time_type t( 0.0 * si::second );
time_type dt( 0.1 * si::second );
state_type x( 1.0 * si::meter , 0.0 * si::meter_per_second ) , x2;
stepper.initialize( x , t , dt );
stepper.do_step( oscillator );
stepper.calc_state( dt / 2.0 , x2 );
}
void check_stepper_concept( Stepper &stepper , System system , typename Stepper::deriv_type &x )
{
typedef Stepper stepper_type;
typedef typename stepper_type::deriv_type container_type;
typedef typename stepper_type::order_type order_type;
typedef typename stepper_type::time_type time_type;
stepper.do_step( system , x , 0.0 , 0.1 );
}
void loop()
{
val=encoder/faktor;
if (val < minimum)
{val=minimum;
encoder=minimum*faktor;}
if (val > maximum)
{val=maximum;
encoder=maximum*faktor;}
if (val !=val_old)
{
sprintf(buffer,"%3d",val);
digitalWrite(stepper_enable, LOW);
lcd.setCursor(10, 2);
lcd.print(buffer);
val_old=val;
digitalWrite(stepper_enable, HIGH);
steps=val - stepper_position;
stepper.step(1);
stepper_position=val;
}
else
{digitalWrite(stepper_enable, LOW);}
digitalWrite(stepper_enable, HIGH);
stepper.step(1);
}
void operator()( void )
{
/* We have to specify the desired precision in advance! */
mpf_set_default_prec( precision );
mpf_t eps_ , unity;
mpf_init( eps_ ); mpf_init( unity );
mpf_set_d( unity , 1.0 );
mpf_div_2exp( eps_ , unity , precision-1 ); // 2^(-precision+1) : smallest number that can be represented with used precision
value_type eps( eps_ );
Stepper stepper;
state_type x;
x = 0.0;
stepper.do_step( constant_system , x , 0.0 , 0.1 );
BOOST_MESSAGE( eps );
BOOST_CHECK_MESSAGE( abs( x - value_type( 0.1 , precision ) ) < eps , x - 0.1 );
}
void loop()
{
val = analogRead(1);
if (val > forward_threshold) {
stepper.step(val - forward_threshold);
}
else if (val < reverse_threshold) {
stepper.step(-(reverse_threshold - val));
}
else{
}
Serial.print("val: ");
Serial.print(val);
Serial.println(" ");
}
void loop() {
n = digitalRead(encoder0PinA);
if ((encoder0PinALast == LOW) && (n == HIGH) ) {
if ((digitalRead(encoder0PinB) == LOW) && (encoder0Pos > encoder_min)) {
digitalWrite(stepper_enable, HIGH);
encoder0Pos--;
stepper.step(-1);
} else {
if (encoder0Pos < encoder_max) {
digitalWrite(stepper_enable, HIGH);
encoder0Pos++;
stepper.step(1);
}
}
Serial.print (encoder0Pos);
Serial.print ("/");
digitalWrite(stepper_enable, LOW);
lcd.setCursor(0, 2);
lcd.print("Position:");
sprintf(buffer,"%4d",encoder0Pos);
lcd.setCursor(10, 2);
lcd.print(buffer);
}
encoder0PinALast = n;
}
void check_controlled_stepper_concept( Stepper &stepper , System system , typename Stepper::state_type &x )
{
typedef Stepper stepper_type;
typedef typename stepper_type::deriv_type container_type;
//typedef typename stepper_type::order_type order_type; controlled_error_stepper don't necessarily have a order (burlish-stoer)
typedef typename stepper_type::time_type time_type;
time_type t = 0.0 , dt = 0.1;
controlled_step_result step_result = stepper.try_step( system , x , t , dt );
BOOST_CHECK_MESSAGE( step_result == success , "step result: " << step_result ); // error = 0 for constant system -> step size is always too small
}
void controlStepper()
{ //Serial.println("StepperCtrl");
//stepper.setSpeed(pot1.getValue()/10);
if (tactileSw1.read()){
Serial.println("sw1");
if(slideSw1.readPin1())
stepper.step(1);
else {if (slideSw1.readPin2())
stepper.step(-1);}
delay(100);
}
else if (tactileSw2.read()){
Serial.println("sw2");
if(slideSw1.readPin1())
stepper.step(10);
else {if (slideSw1.readPin2())
stepper.step(-10);}
delay(100);
}
}
void operator()( void )
{
mpf_set_default_prec( precision );
mpf_t eps_ , unity;
mpf_init( eps_ ); mpf_init( unity );
mpf_set_d( unity , 1.0 );
mpf_div_2exp( eps_ , unity , precision-1 ); // 2^(-precision+1) : smallest number that can be represented with used precision
value_type eps( eps_ );
Stepper stepper;
state_type x;
x = 0.0;
value_type t(0.0);
value_type dt(0.1);
stepper.try_step( constant_system , x , t , dt );
BOOST_MESSAGE( eps );
BOOST_CHECK_MESSAGE( abs( x - value_type( 0.1 , precision ) ) < eps , x - 0.1 );
}
typename Stepper::time_type integrate_const_steps(
Stepper &stepper ,
DynamicalSystem &system ,
typename Stepper::container_type &state ,
typename Stepper::time_type start_time ,
typename Stepper::time_type dt ,
size_t num_of_steps ,
Observer &observer
)
{
stepper.adjust_size( state );
size_t iteration = 0;
while( iteration < num_of_steps )
{
observer( start_time , state , system );
stepper.do_step( system , state , start_time , dt );
start_time += dt;
++iteration;
}
observer( start_time , state , system );
return start_time;
}
void check_controlled_stepper( Stepper &stepper )
{
typedef Stepper stepper_type;
typedef typename stepper_type::state_type state_type;
typedef typename stepper_type::value_type value_type;
typedef typename stepper_type::deriv_type deriv_type;
typedef typename stepper_type::time_type time_type;
time_type t( 0.0 * si::second );
time_type dt( 0.1 * si::second );
state_type x( 1.0 * si::meter , 0.0 * si::meter_per_second );
// test call method one
stepper.try_step( oscillator , x , t , dt );
}
void setup()
{
// begin the serial communication
Serial.begin(9600);
pinMode(m1, OUTPUT);
pinMode(m2, OUTPUT);
pinMode(m3, OUTPUT);
pinMode(m4, OUTPUT);
pinMode(led, OUTPUT);
// set the speed of the motor to 30 RPMs
stepper.setSpeed(30);
}
size_t integrate_adaptive(
Stepper stepper , System system , State &start_state ,
Time start_time , Time end_time , Time dt ,
Observer observer , stepper_tag
)
{
size_t steps = static_cast< size_t >( (end_time-start_time)/dt );
Time end = detail::integrate_n_steps( stepper , system , start_state , start_time ,
dt , steps , observer , stepper_tag() );
if( less_with_sign( end , end_time , dt ) )
{ //make a last step to end exactly at end_time
stepper.do_step( system , start_state , end , end_time - end );
steps++;
typename omplext_odeint::unwrap_reference< Observer >::type &obs = observer;
obs( start_state , end_time );
}
return steps;
}
size_t integrate_adaptive(
Stepper stepper , System system , State &start_state ,
Time start_time , Time end_time , Time dt ,
Observer observer , stepper_tag
)
{
size_t steps = boost::numeric::odeint::detail::integrate_const(
stepper , system , start_state , start_time ,
end_time , dt , observer , stepper_tag() );
if( steps*dt < end_time )
{ //make a last step to end exactly at end_time
stepper.do_step( system , start_state , steps*dt , end_time-steps*dt );
steps++;
typename boost::unwrap_reference< Observer >::type &obs = observer;
obs( start_state , end_time );
}
return steps;
}
void operator()( void )
{
Stepper stepper;
initializing_stepper init_stepper;
const int o = stepper.order()+1; //order of the error is order of approximation + 1
const state_type x0 = {{ 0.0 , 1.0 }};
state_type x1 = x0;
double t = 0.0;
double dt = 0.2;
// initialization, does a number of steps already to fill internal buffer, t is increased
// we use the rk78 as initializing stepper
stepper.initialize( boost::ref(init_stepper) , osc() , x1 , t , dt );
double A = std::sqrt( x1[0]*x1[0] + x1[1]*x1[1] );
double phi = std::asin(x1[0]/A) - t;
// do a number of steps to fill the buffer with results from adams bashforth
for( size_t n=0 ; n < stepper.steps ; ++n )
{
stepper.do_step( osc() , x1 , t , dt );
t += dt;
}
// now we do the actual step
stepper.do_step( osc() , x1 , t , dt );
// only examine the error of the adams-bashforth step, not the initialization
const double f = 2.0 * std::abs( A*sin(t+dt+phi) - x1[0] ) / std::pow( dt , o ); // upper bound
std::cout << o << " , " << f << std::endl;
/* as long as we have errors above machine precision */
while( f*std::pow( dt , o ) > 1E-16 )
{
x1 = x0;
t = 0.0;
stepper.initialize( boost::ref(init_stepper) , osc() , x1 , t , dt );
A = std::sqrt( x1[0]*x1[0] + x1[1]*x1[1] );
phi = std::asin(x1[0]/A) - t;
// now we do the actual step
stepper.do_step( osc() , x1 , t , dt );
// only examine the error of the adams-bashforth step, not the initialization
std::cout << "Testing dt=" << dt << " , " << std::abs( A*sin(t+dt+phi) - x1[0] ) << std::endl;
BOOST_CHECK_LT( std::abs( A*sin(t+dt+phi) - x1[0] ) , f*std::pow( dt , o ) );
dt *= 0.5;
}
}
void setup() {
pinMode (encoder0PinA,INPUT);
pinMode (encoder0PinB,INPUT);
pinMode (stepper_enable, OUTPUT);
Serial.begin (9600);
stepper.setSpeed(250);
digitalWrite(stepper_enable, HIGH);
lcd.begin(20, 4);
lcd.clear();
lcd.print("Stepper, Vers. 1.0");
}
Time integrate_n_steps(
Stepper stepper , System system , State &start_state ,
Time start_time , Time dt , size_t num_of_steps ,
Observer observer , stepper_tag )
{
typename odeint::unwrap_reference< Observer >::type &obs = observer;
Time time = start_time;
for( size_t step = 0; step < num_of_steps ; ++step )
{
obs( start_state , time );
stepper.do_step( system , start_state , time , dt );
// direct computation of the time avoids error propagation happening when using time += dt
// we need clumsy type analysis to get boost units working here
time = start_time + static_cast< typename unit_value_type<Time>::type >( step+1 ) * dt;
}
obs( start_state , time );
return time;
}