Example #1
0
/**
 * Finds root in the interval \f$ [t1,t2] \f$.
 */
int RootFinder::solve(double t1, double t2, double* root) {
    switch(method) {
	case BISECTION: 
	    return bisection(t1, t2, root);
	case BRENTS_METHOD: 
	    return brents_method(t1, t2, root);
	case REGULA_FALSI: 
	    return regula_falsi(t1, t2, root);
        default: 
	    return false;			    
    }
}
Example #2
0
int main( int argc, char*argv[]) {

  int root = 0;
  double t;
  double t_test;
  double t_next;
  double tgo;
  double dt = 0.2;
  REGULA_FALSI rf;

  reset_regula_falsi(t, &rf);
  rf.error_tol = 1.0e-15;
  rf.mode = Any;

  for (t=0.0; t<15.0; t+=dt) {

      t_next = t + dt;
      t_test = t;

      rf.error = sin( t_test);
      tgo = regula_falsi(t_test, &rf);
      while ( ( (t_test + tgo) < t_next) && !root) {
          t_test += tgo;
          rf.error = sin( t_test);
          tgo = regula_falsi(t_test, &rf);

          if (fabs(tgo) < rf.error_tol) {
              printf("ROOT @ %18.14g\n", t_test);
              root = 1;
              reset_regula_falsi(t_test, &rf);
          }
      }
      root = 0;
  }

  exit(0);

}
Example #3
0
/* The cannonball sim's dynamic job */
double cannon_impact( CANNON* C ) {
    double tgo ; /* time-to-go */
    double now ; /* current integration time. */
    
    C->rf.error = C->pos[1] ;              /* Specify the event boundary. */
    now = get_integ_time() ;               /* Get the current integration time */
    tgo = regula_falsi( now, &(C->rf) ) ;  /* Estimate remaining integration time. */ 
    if (tgo == 0.0) {                      /* If we are at the event, it's action time! */
        now = get_integ_time() ;
        reset_regula_falsi( now, &(C->rf) ) ; 
        C->impact = 1 ;
        C->impactTime = now ;
        C->vel[0] = 0.0 ; C->vel[1] = 0.0 ;
        C->acc[0] = 0.0 ; C->acc[1] = 0.0 ;
        fprintf(stderr, "\n\nIMPACT: SimTime = %.9f, pos = %.9f\n\n", now, C->pos[0] ) ;
    }
    return (tgo) ;
}
int sweep_regula_falsi(double (*func)(double x),double xstart,double xstop,double xinc,int nmax,double tol) {
  double a,b,fa,fb;
  int retval;

  xstop = xstop + (xinc * 0.5);
  a = xstart;
  fa = (*func)(a);
  b = a + xinc;
  while (((xinc > 0.0) && (b < xstop)) || ((xinc < 0.0) && (b > xstop))) {
    fb = (*func)(b);
    if ((fa * fb) < 0.0) {   /*root bracketed, converge with regula_falsi*/
      retval = regula_falsi(func,a,b,nmax,tol);
      if (retval > 0) return(retval);
    }
    a = b;
    fa = fb;
    b = b + xinc;
  }
  return(0);
}
Example #5
0
double sched_dyn_event(       /* RETURN: s  Time to go to event */
    SCHEDULE * S)             /* INOUT:  --  */
{

    double tgo;  /* Estimated time to go (in seconds) to the defined event */
    double now = get_integ_time();

    /* CALCULATE TIME TO GO FOR EVENT */
    S->rf.error = S->mass - 1.2;
    tgo = regula_falsi( now , &(S->rf) );

    if ( tgo == 0.0 ) {
        /* FIRE EVENT */
        reset_regula_falsi( now , &(S->rf) );
        /* Make mass zig zag once it hits 1.2kg */
        S->mass = S->mass - 0.01;
    }

    return( tgo ) ;
}
Example #6
0
void IBall_sim( Integrator_type Alg,
                std::ostream&   dataout) {

    BALL   ball;
    long   tick;
    double sim_time;
    REGULA_FALSI rf;

    const double seconds_per_tick = 0.01;
    const double initial_angle = 30.0;
    const double initial_speed = 50.0;
    const int    doing_dynamic_events = 1;

    dataout.width(16);
    dataout.precision(14);

    // ========================================
    //             Initialization
    // ========================================
    tick = 0;
    sim_time = 0.0;

    ball.pos[0] = 0.0;
    ball.pos[1] = 0.0;
    ball.vel[0] = initial_speed * cos( initial_angle * RAD_PER_DEG);
    ball.vel[1] = initial_speed * sin( initial_angle * RAD_PER_DEG);

    Trick::Integrator *I = Trick::getIntegrator( Alg, 4, seconds_per_tick );

    sim_time = tick * seconds_per_tick ;

    // Initialize Regula Falsi.
    reset_regula_falsi(sim_time, &rf);
    rf.error_tol = 1.0e-15;
    rf.mode = Any;

    // Note: We don't care what the tgo estimate is because here,
    // we are just initializing the bounds.
    rf.error = ball.pos[0];
    regula_falsi(sim_time, &rf);

    // ========================================
    //               Simulation loop
    // ========================================
    do {

        dataout << sim_time << " " << ball.pos[0] << " " << ball.pos[1] << std::endl;

        I->time = sim_time;

        // ###I### Integrate over the time step.
        integ(I, &ball);

        // Advance time.
        tick++;
        sim_time = tick * seconds_per_tick ;

        // If we are looking for roots ...
        if ( doing_dynamic_events ) {
            double tgo;

            // ###RF### Given the current error, estimate how far (in time) we are from a root.
            rf.error = ball.pos[0];
            tgo = regula_falsi(sim_time, &rf);

            // If regula_falsi found a root in the last interval ...
            if ( tgo < seconds_per_tick) {

                int root_found = 0;
                double t_test = sim_time;

                // Iterate until we find the root.

                // NOTE: the regula_falsi function gives up and returns with tgo=0 if
                // it hasn't converged on a root after 20 iterations.
                while (! root_found) {

                    // ###I### Integrate over the time-correction.
                    I->dt = tgo;
                    integ(I, &ball);

                    t_test += tgo;

                    // ###RF### Given the current error, estimate how far (in time) we are from the root.
                    rf.error = ball.pos[0];
                    tgo = regula_falsi( t_test, &rf);

                    // If the estimated time-to-go is less than the chosen tolerance, then we have our root.
                    if (fabs( tgo) < rf.error_tol) {
                        printf("ROOT@ %18.14g\n", t_test);
                        root_found = 1;
                        reset_regula_falsi(t_test, &rf);
                    }
                }
                root_found = 0;

                // ###I### Integrate from t=t_test back (forward actually) to t=sim_time.
                I->dt =  sim_time - t_test ;
                integ(I, &ball);

                // Restore the normal time-step.
                I->dt = seconds_per_tick;
            }

        } // End of doing_dynamic_events.

    } while (ball.pos[0] >= -3.0);

    dataout << sim_time << " " << ball.pos[0] << " " << ball.pos[1] << std::endl;

    delete( I);
}