/*
 *  ============================================================================
 *  NumericalPrecision.java: Simple experiments to explore limitations of
 *  finite precision representation of numbers and finite-precision arithmetic.
 *
 *  Note. Binary representation of fraction 0.10 has an infinite series.
 *
 *  Written By: Mark Austin                                        February 2007
 *  ============================================================================
 */

import java.lang.Math;

public class NumericalPrecision {
   public static void main ( String [] args ) {

       System.out.println("");
       System.out.println("Part 1. Experiment with two 32-bit floating point nos");
       System.out.println("=====================================================");

       // Define two floating point numbers

       float fA = 4.0f;
       float fB = 3.0f;

       // Print variables to default accuracy

       System.out.println("Print default values of variables");
       System.out.println(" fA = " + fA );
       System.out.println(" fB = " + fB );

       // Compute and print fA/fB .....

       float fC = fA/fB;
       System.out.println(" fC (fA/fB)= " + fC );

       // Now subtract one fA/fB .....

       float fD = (float) (fC-1.0);
       System.out.println(" fD (fA/fB - 1)= " + fD );

       // ==============================================
       // Multiply fD by 300 (the answer should be 100).
       // ==============================================

       System.out.println(" 300*fD = " + 300*fD );

       // Compute sum through addition ....

       float fSum = 0.0f;
       for ( int i = 1; i <= 300; i = i + 1)
           fSum = fSum + fD;

       System.out.println(" fSum (300*fD) = " + fSum );

       // ======================================================
       // Multiply fD by 300,000 (the answer should be 100,000).
       // ======================================================

       System.out.println(" 300000*fD = " + 300000*fD );

       // Compute sum through addition ....

       fSum = 0.0f;
       for ( int i = 1; i <= 300000; i = i + 1)
           fSum = fSum + fD;

       System.out.println(" fSum (300,000*fD) = " + fSum );

       // Repeat exercise with double precision (64-bit) arithmetic....

       System.out.println("");
       System.out.println("Part 2. Experiment with two 64-bit floating point nos");
       System.out.println("=====================================================");

       // Define two floating point numbers

       double dE = 4.0; double dF = 3.0;

       // Print variables to default accuracy

       System.out.println("Print default values of variables");
       System.out.println(" dE = " + dE );
       System.out.println(" dF = " + dF );

       // Compute and print dE/dF .....

       double dG = dE/dF;
       System.out.println(" dG (dE/dF)= " + dG );

       // Now subtract one dE/dF .....

       double dH = dG-1.0;
       System.out.println(" dH (dE/dF - 1) = " + dH );

       // ==============================================
       // Multiply dH by 300 (the answer should be 100).
       // ==============================================

       System.out.println(" 300*dH = " + 300*dH );

       // Compute sum through addition ....

       double dSum = 0.0;
       for ( int i = 1; i <= 300; i = i + 1)
           dSum = dSum + dH;

       System.out.println(" dSum (300*dD) = " + dSum );

       // ======================================================
       // Multiply dH by 300,000 (the answer should be 100,000).
       // ======================================================

       System.out.println(" 300000*dH = " + 300000*fD );

       // Compute sum through addition ....

       dSum = 0.0;
       for ( int i = 1; i <= 300000; i = i + 1)
           dSum = dSum + dH;

       System.out.println(" dSum (300,000*fH) = " + dSum );

       System.out.println("");
       System.out.println("Part 3. Experiment with fraction 0.10");
       System.out.println("=====================================================");

       double dFraction = 0.1;
       System.out.println("Print default value of 0.10");
       System.out.println(" dFraction = " + dFraction );

       System.out.println(" 10*0.10 = " + 10*dFraction );

       dSum = 0.0;
       for ( int i = 1; i <= 10; i = i + 1)
           dSum = dSum + dFraction;

       System.out.println(" Sum 0.10 ten times = " + dSum );

       System.out.println(" 1000000*0.10 = " + 1000000*dFraction );

       dSum = 0.0;
       for ( int i = 1; i <= 1000000; i = i + 1)
           dSum = dSum + dFraction;

       System.out.println(" Sum 0.10 one million times = " + dSum );

       System.out.println(" 10000000*0.10 = " + 10000000*dFraction );

       dSum = 0.0;
       for ( int i = 1; i <= 10000000; i = i + 1)
           dSum = dSum + dFraction;

       System.out.println(" Sum 0.10 ten million times = " + dSum );
       System.out.println("=====================================================");

   }
}