Module 3: Calculus Revisited - Computationally

Let's start by asking a few questions about the Ball-Drop problem:

• What is the final velocity when the ball hits the ground after being dropped from a height of 1000?
• At what height should one drop the ball to get a final velocity of approximately 200?
• At what time and height is the velocity half the final velocity (when dropped from a height of 1000)?

Now let's tackle these questions:

• First, we'll start by modifying the simulator to return the final velocity instead of time: (source file)

  public class BallDropSimulator2 {
  
      double vy;
      double t;
  
  
      public double run (double height)
      {
  	// Initialize variables.
          double a = 9.8;
  
          // We'll use "y" for distance (falling along y-axis) and "vy" for velocity.
          double y = height;
          vy = 0;
  
          t = 0;
          double delT = 0.001;
  
  	while (true) {
  	    // Update time.
  	    t += delT;
  
              // Decrease velocity by downward acceleration.
  	    vy = vy - delT * a;
  
              // Increase distance (y) according to velocity (which will reduce height)
              y = y + delT * vy;
  
  	    if (y <= 0) {   // Stop if it's hit the ground.
                  break;
  	    }
  	}
  
          return y;
      }
  
  
      public double getV ()
      {
          return vy;
      }
  
  
      public double getT ()
      {
          return t;
      }
  
  }
       

  Note:
  • We've created methods to return the final velocity and the time at which the ball hits the ground.
  • To do this, we've had to make these variables global.
  • We've increased the accuracy slightly (from 0.01 to 0.001).

• Now let's write a separate program to use the simulator and answer the first question: (source file)

  public class BallDropSimulatorExercise {
  
      public static void main (String[] argv)
      {
          BallDropSimulator2 sim = new BallDropSimulator2 ();
  
          // Drop the ball from a height of 1000.
          sim.run (1000);
          
          // Obtain final velocity and time taken for the fall.
          double finalVelocity = sim.getV ();
          double timeTaken = sim.getT ();
  
          System.out.println ("finalVelocity=" + finalVelocity + " time=" + timeTaken);
      }
      
  }
      

• To answer the second question, we will try different height values systematically: (source file)

  public class BallDropSimulatorExercise2 {
  
      public static void main (String[] argv)
      {
          BallDropSimulator2 sim = new BallDropSimulator2 ();
  
          // Drop the ball from a height of 1000.
          double height = 1000;
          sim.run (height);
          
          double finalVelocity = sim.getV ();
  
          while ( Math.abs (finalVelocity + 200) > 1 ) {
              // Try different heights systematically.
              height += 1;
              sim.run (height);
              finalVelocity = sim.getV ();
          }
  
          System.out.println ("Height required: " + height);
      }
      
  }
      

  Note:
  • Because velocities are negative (going down), the difference the velocity and 200 has a + sign.

Exercise 28: How many times is the loop iterated? Can you think of a more efficient algorithm for the same problem?

Exercise 29: Modify the code to answer the third question: At what time and height is the velocity half the final velocity (when dropped from a height of 1000)?

Next, let's look at the ball-tossing problem (toss a ball up with some initial velocity) and ask these questions:

• What is the maximum height reached by the ball?
• What initial velocity is needed to reach a height of 1000?
• Suppose the ball is launched with an initial velocity of 50, and suppose we observe the velocity at a height of 100. Is the velocity the same going up as it is going down at this height?

Let's answer some of these questions now:

• First, we'll modify the simulator to return the velocity: (source file)

  public class BallTossSimulator2 {
  
      // We made this a global variable ...
      double vy;
  
      public double run (double stopTime, double initVelocity)
      {
  	// Initialize variables.
          double a = 9.8;
          vy = initVelocity;
          double y = 0;
          double t = 0;
          double delT = 0.01;
  
  	while (true) {
  	    // Update time.
  	    t += delT;
  
              // Increase velocity accordingly.
  	    vy = vy - delT * a;
  
              // Increase distance according to velocity.
              y = y + delT * vy;
  
  	    if ((t >= stopTime) || (y <= 0)) {
                  break;
  	    }
  	}
  
          return y;
      }
  
      
      public double getV ()
      {
          // ... so that it's accessible here.
          return vy;
      }
  
  }
      

• Notice the input parameters to the run() method:
  • One parameter is the length of the simulation (which might stop before the ball hits the ground).
  • The other is the launch velocity.

• How do we know how much extra time to give (to allow for the ball to come down and hit the ground)?
       => We don't - so let's find out by writing a simple program: (source file)

  public class BallTossExercise {
  
      public static void main (String[] argv)
      {
          // Make an instance of our new simulator.
          BallTossSimulator2 sim = new BallTossSimulator2 ();
  
          // We'll start by trying 1 second.
          double stopTime = 1;
          double y = sim.run (stopTime, 50);
  
          // As long as we haven't hit ground, keep trying higher values of t.
          while (y > 0) {
              stopTime += 10;
              y = sim.run (stopTime, 50);
          }
  
          // This should be sufficient:
          System.out.println ("stopTime=" + stopTime + " y=" + y);
      }
  
  }
      

  (Turns out: 12 seconds is enough).

• OK, next let's find the maximum height reached:
  • How do we do this?
  • Here's one idea: we try different stop-time's until, in two successive attempts, the height decreases.
  Here's the program: (source file)

  public class BallTossExercise2 {
  
      public static void main (String[] argv)
      {
          // Make an instance of our new simulator.
          BallTossSimulator2 sim = new BallTossSimulator2 ();
  
          // Find the height reached at t=1 and t=2
          double stopTime = 1;
          double prevY = sim.run (stopTime, 50);
          stopTime = 2;
          double nextY = sim.run (stopTime, 50);
  
          while (nextY > prevY) {
              // As long as y(t+1) > y(t), repeat.
              prevY = sim.run (stopTime, 50);
              stopTime = stopTime + 1;
              nextY = sim.run (stopTime, 50);
          }
  
          // Now we're sure that y(t+1) < y(t)
          System.out.println ("stopTime=" + stopTime + " prevY=" + prevY + " nextY=" + nextY);
      }
  
  }
  
       

• We can add to this code to find the velocity needed to reach a height of 1000: (source file)

  public class BallTossExercise3 {
  
      public static void main (String[] argv)
      {
          for (double initVelocity=50; initVelocity<500; initVelocity+=50) {
              // Try this initial velocity:
              double heightReached = getMaxHeight (initVelocity);
              if (heightReached > 1000) {
                  // If we've exceeded 1000, then stop.
                  System.out.println ("initV=" + initVelocity + "  height=" + heightReached);
                  break;
              }
          }
      }
      
  
      static double getMaxHeight (double initVelocity)
      {
          // Make an instance of the simulator.
          BallTossSimulator2 sim = new BallTossSimulator2 ();
  
          // Find the height reached at t=1 and t=2
          double stopTime = 1;
          double prevY = sim.run (stopTime, initVelocity);
          stopTime = 2;
          double nextY = sim.run (stopTime, initVelocity);
  
          while (nextY > prevY) {
              // As long as y(t+1) > y(t), repeat.
              prevY = sim.run (stopTime, initVelocity);
              stopTime = stopTime + 1;
              nextY = sim.run (stopTime, initVelocity);
          }
  
          // Now we're sure that y(t+1) < y(t)
          System.out.println ("initV=" + initVelocity + "  stopTime=" + stopTime + " prevY=" + prevY + " nextY=" + nextY);
          return prevY;
      }
  
  }
       

  Note:
  • We have made a method out of the sub-problem of "finding the maximum height for a given initial velocity".
  • This sub-problem is then called repeatedly in steps of 50.

Exercise 30: How would you get a more accurate estimate of the initial velocity needed to reach 1000?

Next we will address the third question: is the velocity the same going up and down at a given height?

• We will first modify the simulator as follows:
  • We will stop when a given "target height" is reached.
  • We will decide whether this height has been reached before or after the maximum height has been reached.

• The input parameters now accept the target height, and whether or not one should reach this target before or after the maximum: (source file)

  public class BallTossSimulator3 {
  
      double vy;
  
      public double run (double stopTime, double initVelocity, double targetHeight, boolean beforeMaxHeight)
      {
  	// Initialize variables.
          double a = 9.8;
          vy = initVelocity;
          double y = 0;
          double t = 0;
          double delT = 0.01;
  
          boolean maxReached = false;
  
  	while (true) {
  	    // Update time.
  	    t += delT;
  
              // Increase velocity accordingly.
  	    vy = vy - delT * a;
  
              // Increase distance according to velocity.
              double nextY = y + delT * vy;
  
              double prevY = y;
              y = nextY;
  
              if (y < prevY) {
                  maxReached = true;
              }
              
              if (beforeMaxHeight) {
                  if (y > targetHeight) {
                      // Done.
                      break;
                  }
              }
              else if (maxReached) {
                  if (y < targetHeight) {
                      // Done.
                      break;
                  }
              }
              
  	    if ((t >= stopTime) || (y <= 0)) {
                  break;
  	    }
  	}
  
          return y;
      }
  
      
      public double getV ()
      {
          return vy;
      }
  
  }
       

  Note:
  • We use the same idea (observing successive y values) to see if the maximum has been reached.
  • We wait for "y > target" in the "before" case, and for "y < target" in the "after" case.

• It's easy now to check the "before" and "after" velocities: (source file)

  public class BallTossExercise4 {
  
      public static void main (String[] argv)
      {
          // Make an instance of modified simulator.
          BallTossSimulator3 sim = new BallTossSimulator3 ();
  
          sim.run (1000, 50, 100, true);
          double beforeV = sim.getV ();
          sim.run (1000, 50, 100, false);
          double afterV = sim.getV ();
          
          System.out.println ("before: " + beforeV + "  after: " + afterV);
      }
  
  }
       

Exercise 31: So, is it true that the two velocities are the same? Is there an intuition for why or why not?

Consider these questions about the projectile problem:

• For a fixed velocity of 50, which angle results in the farthest horizontal distance traveled?
       => This is an age-old ballistics problem

• Suppose we want the projectile to hit a target at a distance of 200 from the launch point. Find two combinations of angle and initial velocity to achieve this goal. Of the two, which one has a smaller time-of-flight?

• We'll begin by re-writing the simulator slightly: (source file)

  public class ProjectileSimulator2 {
  
      double x=0, y=0;             // Track (x,y) 
      double vx, vy;               // Velocity components
  
  
      public double run (double angle, double initialVelocity) 
      {
          // Initialize values.
          double delT = 0.001;                      // Interval of time.
          double t = 0;                             // Current time.
          double g = 9.8;                           // 9.8 N 
          double theta = Math.toRadians (angle);    // Convert degrees to radians.
  
          x = 0;
          y = 0;
          
          // Initial vx = component of initialVelocity in x-direction.
          vx = initialVelocity * Math.cos (theta);
  
          // Initial vy = component of initialVelocity in y-direction.
          vy = initialVelocity * Math.sin (theta);
  
          while (y >= 0) {
              // Apply g to vy. Note: vx stays the same.
              vy = vy - g * delT;
              
              // Apply vx to x.
              x = x + vx * delT;
              
              // Apply vy to y.
              y = y + vy * delT;
  
              t = t + delT;
          }
          
          return t;
      }
      
  
      public double getX ()
      {
          return x;
      }
  
  }
       

  Note:
  • The input parameters are: launch angle and velocity.
  • The simulator returns the time taken for the flight.
  • There is a method getX() that we can call to obtain the horizontal distance traveled.

• Next, let's use the initial velocity of 50, and try different angles: (source file)

  public class ProjectileExercise {
  
      public static void main (String[] argv)
      {
          // Make an instance of our new simulator.
          ProjectileSimulator2 sim = new ProjectileSimulator2 ();
  
          // Launch velocity is 50.
          double initV = 50;
          
          // Try angles in the range [10,80]
          for (double angle=10; angle<=80; angle+=1) {
              sim.run (angle, initV);
              double x = sim.getX ();
              System.out.println ("angle=" + angle + " x=" + x);
          }
  
      }
  
  }
       

• A slightly more elegant approach would be to record the the best result in the loop: (source file)

  public class ProjectileExercise2 {
  
      public static void main (String[] argv)
      {
          // Make an instance of our new simulator.
          ProjectileSimulator2 sim = new ProjectileSimulator2 ();
  
          // Launch velocity is 50.
          double initV = 50;
          
          // Try angles in the range [10,80]
          double bestAngle = 10;
          double bestX = 0;
          
          for (double angle=10; angle<=80; angle+=1) {
              sim.run (angle, initV);
              double x = sim.getX ();
              if (x > bestX) {
                  bestAngle = angle;
                  bestX = x;
              }
          }
  
          System.out.println ("Best angle: " + bestAngle);
      }
  
  }
       

Exercise 32: What is the best angle? Run the program and find out. Does it make intuitive sense?

Exercise 33: Write code to solve the second problem: find two angle/velocity combinations to reach a target at a distance of 200. What is the time-of-flight for each?

Problem Solving II