Module 8: Applications

In this and the next few sections, we'll use simple for-loops to compute some of the most famous constants in mathematics, and explore a few mathematical ideas (no background needed).

One key idea in mathematics is the notion of a limit:

• Let x₁, x₂, ..., x_n, ... be a sequence of real numbers.

• For example:

           x1 = 1
           x2 = 3
           x3 = 5
           x4 = 7
           ... (and so on)
      

• A limit explores the idea of what the sequences tends towards.

• The above example grows to ∞ (infinity).

• Example: suppose x_n = 1/n.
         ⇒ Then, x_n gets closer to 0 as n → ∞. Let's explain:
  • First, let's enter values of n to calculate (with a calculator) a few values:

             x1 = 1/1 = 1
             x2 = 1/2 = 0.5
             x3 = 1/3 = 0.3333
             x4 = 1/4 = 0.25
             x5 = 1/5 = 0.20
             ... (skipping a few) ...
             x10 = 1/10 = 0.1
             ... (skipping a few) ...
             x100 = 1/10 = 0.01
             ... (skipping many) ...
             x10000 = 1/10000 = 0.00001
        

  • Clearly, as n gets larger, x_n gets smaller and smaller.

• We say lim_n→∞ 1/n = 0.

• How to say out aloud: "The limit, as n tends to infinity, of the sequence 1/n is zero".

• Note: our goal in this module is to explore the use of programming in discovering math; we will not test you on math.

Next, let's explore some reasoning related to sequences (of numbers):

• We want to understand what happens to the n-th power of a number as n increases.

• Consider the number 3/4 and the sequence (3/4)ⁿ.

• In other words we want to explore what the sequence below "is headed towards".

           x1 = 3/4
           x2 = (3/4)2 = 0.5625
           x3 = (3/4)3 = 0.4218 
           x4 = (3/4)4 = 0.3164
           ... (and so on)
      

• Since (3/4)² = (3/4) × (3/4), one could say that "three-fourths of 3/4" will be smaller than 3/4.
  This is indeed the case:

           x1 = (3/4) = 0.75
           x2 = (3/4)2 = 0.5625 (less than 0.75)
      

• Similarly, (3/4)³ = (3/4) × (3/4)², we'll get an even smaller number that's next in the sequence.

           x1 = (3/4) = 0.75
           x2 = (3/4)2 = 0.5625 
           x3 = (3/4)3 = 0.4218 (less than 0.5625)
      

Let's write a program to verify:

public class TestSequence {

    public static void main (String[] argv)
    {
	// Remember: 3/4 = 0 because it'll be integer division.
	// We need to make this 3.0 / 4.0. 
	double x = 3.0 / 4.0;

	for (int n=2; n<=20; n++) {
	    System.out.println (x);
	    // The next term is 3/4 times the previous.
	    x = (3.0/4.0) * x;
	}
    }

}
    

8.1 Exercise: Write up the above program and verify that successive powers of 3/4 are getting smaller. Now try another number that's less than 1, like 0.95 and examine its successive powers.

Next, let's look at a number that's larger than 1, like 4/3.

• Since (4/3)² = (4/3) × (4/3), one could say that the result will be larger than 4/3.

• Thus, (4/3)ⁿ should get larger.

8.2 Exercise: Change the code above to verify. Now try another number that's bigger than 1, like 1.05, and examine its successive powers.

We can generalize this:

• If x is any number (like 3/4), we're interested in what happens with successive powers xⁿ.

• Note: for simplicity, we'll stick with positive numbers and not deal with powers of negative numbers.

• By the same reasoning as above, if x is smaller than 1, then xⁿ gets closer and closer to 0.

• Similarly, if x is larger than 1, then xⁿ grows unboundedly, towards infinity (but not beyond).

• If x=1, of course, the result is boring: xⁿ=1.

• To summarize for any number x:
  • If x < 1, the limit is 0.
  • If x > 1, the limit is ∞.
  • If x = 1, the limit is 1.

• Observe that the limits are rather stark: only three limits.

A small tweak will make this more interesting:

• Suppose x itself is changing from one iteration to another.

• We'll use the notation x_n to denote the value of x at the n-th iteration.

• For example: at the n-th iteration x could be the n-th odd number:

           x1 = 1
           x2 = 3
           x3 = 5
           x4 = 7
           ... (and so on)
      

• To print the successive powers, we could use code like:

  	for (int n=1; n<=20; n++) {
              // Compute the n-th odd number:
              double x = 2*n-1;
  
              // Use a for-loop to compute xn
              double power = 1;
              for (int j=1; j<=n; j++) {
                  power = power * x;
              }
  
              System.out.println ("n-th power of xn=" + power);
  	}
      

  8.3 Exercise: Write up the above code in OddSequence.java.

• Clearly, the sequence grows very fast towards infinity.

• The fact that x_n is itself increasing (successive odd numbers) and that we're computing higher powers, combines for a "double acceleration" of sorts.

• You also see how extremely large numbers are printed using the so-called floating-point notation (with "E").

• So, now let's take a decreasing sequence and subject that to higher powers to see if they "offset" each other.

• As the decreasing sequence, we'll pick x_n = (1 + 1/n).

• Here are some terms:

           x1 = 1 + 1/1 = 2
           x2 = 1 + 1/2 = 1.5
           x3 = 1 + 1/3 = 1.333
           x4 = 1 + 1/4 = 1.25
           ... (and so on)
      

• Clearly, this is a decreasing sequence.

• We'd like to know what will happen if we raise the successive terms to higher powers:

           (x1)1 = (1 + 1/1)1 = ?
           (x2)2 = (1 + 1/2)2 = ?
           (x3)3 = (1 + 1/3)3 = ?
           (x4)4 = (1 + 1/4)4 = ?
           ... where is this headed?
      

• Here, even though successive x's are decreasing, we are "powering" them to higher power.

• So: does this new sequence decrease to zero or grow to infinity?

• Now let's compute successively higher powers:

  	for (int n=1; n<=20; n++) {
              // Compute the n-th term:
  	    double x = 1.0 + 1.0/n;
  
              // Use a for-loop to compute xn
              double power = 1;
              for (int j=1; j<=n; j++) {
                  power = power * x;
              }
  
              System.out.println ("n-th power of xn=" + power);
  	}
      

8.4 Exercise: Edit, compile and execute the program, writing your code in StrangeSequence.java. Try much larger values of n. What does the limit of the sequence appear to be?

The limit of the above sequence is the celebrated and important mathematical constant e:

About e:

• e is approximately 2.718...

• It is just as important and practical as its better known cousin, π.

• e turns up all over the place in math and engineering.

• e, like π, is transcendental.

• It's unexpectedly interesting that such a simple combination of a decreasing sequence and higher powers results in this very important constant.