Universidad Carlos III de Madrid

The following program computes the value of pi with the desired precision (the number of desired decimal places is passed as a command argument).

import java.math.BigDecimal;
import java.math.MathContext;

public class PiCalc {

    private int numDigits;
    private MathContext mc;

    public PiCalc(int numDigits) {
        this.numDigits = numDigits;
        mc = new MathContext(numDigits);
    }

    public BigDecimal compute() {
        BigDecimal pi = new BigDecimal(0);
        BigDecimal limit = new BigDecimal(1).movePointLeft(numDigits);
        boolean stop = false;
        for (int k = 0; !stop; k++) {
            BigDecimal piK = piFunction(k);
            pi = pi.add(piK);
            if (piK.compareTo(limit) < 0) {
                stop = true;
            }
        }
        return pi.round(mc);
    }

    private BigDecimal piFunction(int k) {
        int k8 = 8 * k;
        BigDecimal val1 = new BigDecimal(4);
        val1 = val1.divide(new BigDecimal(k8 + 1), mc);
        BigDecimal val2 = new BigDecimal(-2);
        val2 = val2.divide(new BigDecimal(k8 + 4), mc);
        BigDecimal val3 = new BigDecimal(-1);
        val3 = val3.divide(new BigDecimal(k8 + 5), mc);
        BigDecimal val4 = new BigDecimal(-1);
        val4 = val4.divide(new BigDecimal(k8 + 6), mc);
        BigDecimal val = val1;
        val = val.add(val2);
        val = val.add(val3);
        val = val.add(val4);
        BigDecimal multiplier = new BigDecimal(16);
        multiplier = multiplier.pow(k);
        BigDecimal one = new BigDecimal(1);
        multiplier = one.divide(multiplier, mc);
        val = val.multiply(multiplier);
        return val;
    }

    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("One command-line argument expected: number of "
                               + "digits.");
        } else {
            PiCalc piCalc = new PiCalc(Integer.parseInt(args[0]));
            System.out.println(piCalc.compute());
        }
    }
}

Take a look at its source code without paying too much attention to its details and answer the following questions.

Import the program into Eclipse and run it several times with varied precisions. Note how the program takes more and more time to execute as you ask for higher precisions (in the next section you will understand why is that).

Use the Eclipse debugger to understand how the program works. Set a breakpoint in the first line of the method compute() (menu Run / Toggle Breakpoint). Run the program in debug mode, using Debug instead of Run. The program will begin its execution and will stop at your breakpoint.

You will be asked to change the Eclipse perspective to the Debugging Perspective, which will allow you to control and obtain information about the ongoing debugging session. You will be able to see your source code, along with a marker on the line that is going to be executed next. You can also see the values of your program variables (at first, only this is shown, which is the object with the method where the breakpoint is; if you unfold it, you will be able to see the values of all its attributes). You can also see the Console.

Now that the program is waiting at the breakpoint, you can resume its execution in several ways:

You can also cancel the debugging mode by using the option Run / Terminate.

Debug the program using 10 as its command line argument. Count the number of iterations performed on the loop inside the method compute() before getting the final value of pi. Repeat this for bigger arguments. What can you say about the time it takes to execute the program as a function of its argument?

In a new debugging session, keep track of the value of the variable piK on each loop iteration. How is this value changing with each iteration of the loop?

What is the role of the limit variable in the program? Run additional debugging sessions if you need to.

What is the mathematical expression that the program is using to calculate the value of pi? You can answer this question by thinking about the source code above and using the debugger.

Write a new Java program to calculate the area of a circle knowing it radius. This program will have a main method that will receive as its arguments the decimal places of pi for the calculation of the solution and the radius of the circle. The program must write the calculated area to its standard output.

The program must use the class PiCalc presented above to generate a suitable value of pi for its calculations. It must also use the class BigDecimal.

import java.math.BigDecimal;

public class CircleAreaCalc {

    private BigDecimal pi;

    public CircleAreaCalc(int numDigits) {
        PiCalc piCalc = new PiCalc(numDigits);
        pi = piCalc.compute();
    }

    public BigDecimal area(BigDecimal radius) {
        BigDecimal area = radius.pow(2);
        area = area.multiply(pi);
        return area;
    }

    public static void main(String[] args) {
        if (args.length != 2) {
            System.err.println("Two command-line arguments expected: number of "
                               + "digits and circle radius.");
        } else {
            int numDigits = Integer.parseInt(args[0]);
            BigDecimal radius = new BigDecimal(args[1]);
            CircleAreaCalc circleAreaCalc = new CircleAreaCalc(numDigits);
            System.out.println(circleAreaCalc.area(radius));
        }
    }
}

Write a new Java program to calculate the sum of the areas of several circles, knowing their radii. The program will have a main method with the following arguments: the desired precision on pi and one or more radii values (one per circle). The program must write the solution to the standard output.

This program must use the class from the previous section and BigDecimal.

import java.math.BigDecimal;

public class ManyCirclesAreaCalc {

    public static void main(String[] args) {
        if (args.length < 1) {
            System.err.println("At least one argument expected: "
                               + "number of digits for pi.");
        } else {
            int numDigits = Integer.parseInt(args[0]);
            BigDecimal total = new BigDecimal(0.0);
            CircleAreaCalc circleAreaCalc = new CircleAreaCalc(numDigits);
            for (int i = 1; i < args.length; i++) {
                total = total.add(circleAreaCalc.area(new BigDecimal(args[i])));
            }
            System.out.println(total);
        }
    }
}