import javax.swing.JOptionPane;

/** Add up all Fraction values given on the command line.
 *  Print the total and the smallest one entered. */

public class AddFractions 
{
     public static void main (String[] args)
     {    String response = "No values entered.";    // just in case
          if (args != null && args.length > 0)
               try
               {    Numeric total = Fraction.ZERO.valueOf (args[0]);
                    Numeric smallestSoFar = total;
                    for (int k = 1;  k < args.length;  k++)
                    {    Numeric data = total.valueOf (args[k]);
                         total = total.add (data);
                         if (smallestSoFar.compareTo (data) > 0)
                              smallestSoFar = data;
                    }
                    response = "total = " + total.toString()
                        + "; smallest = " + smallestSoFar.toString();
               }catch (RuntimeException e)
               {    response = "Some entry was not fractional.";
               }
          JOptionPane.showMessageDialog (null, response);
          System.exit (0);
     }    //======================
}

import java.io.BufferedReader;

public abstract class Numeric implements Comparable
{
     /** Convert to the appropriate subclass. Return null if par is
      *  null or "".  Throw NumberFormatException if wrong form. */

     public abstract Numeric valueOf (String par);


     /** Convert to string form. */

     public abstract String toString();


     /** Convert to a real-number equivalent. */

     public abstract double doubleValue();


     /** Tell whether the executor equals the parameter. */

     public abstract boolean equals (Object ob);


     /** Like String's compareTo: a positive means ob is "smaller". 
      *  Throw NullPointerException if ob is null.
      *  Throw ClassCastException if ob is not the same type. */

     public abstract int compareTo (Object ob); 


     /** Return a new Numeric that is the sum of both. 
      *  Return null if they are the same subtype but the answer 
      *  is not computable. Throw an Exception if par is null or 
      *  the executor and par are different subtypes. */

     public abstract Numeric add (Numeric par);


     /** Same as add, except return executor minus par. */

     public abstract Numeric subtract (Numeric par); 


     /** Same as add, except return executor times par. */

     public abstract Numeric multiply (Numeric par);


     /** Return the larger of the two Numeric values.  Throw an 
      *  Exception if they are not both non-null values of the 
      *  same Numeric type.*/

     public static Numeric max (Numeric data, Numeric other)
     { return (data.compareTo (other) > 0)  ?  data  :  other;
     }    //======================


     /** Return the square of the executor. */

     public Numeric square()
     {    return this.multiply (this);
     }    //======================


     /** Read Numeric values from the BufferedReader and add them 
      *  to the executor, until null is seen or until a value 
      *  cannot be added to the executor.  Return the total. */

     public Numeric addMore (BufferedReader source)
     {    Numeric total = this;
          try
          {    Numeric data = this.valueOf (source.readLine());
               while (data != null && total != null)
               {    total = total.add (data);
                    data = this.valueOf (source.readLine());
               }
          }catch (Exception e)
          {   // no need for any statements here; just return total
          }
          return total;
     }    //======================
}     

public abstract class BasicGame
{
     public final void playManyGames()  
     {    playOneGame();
                    while (javax.swing.JOptionPane.showConfirmDialog (null,
                             "again?") == javax.swing.JOptionPane.YES_OPTION)
               playOneGame();
     }  //======================


     public final void playOneGame()  
     {    askUsersFirstChoice();
          while (shouldContinue())
          {    showUpdatedStatus();
               askUsersNextChoice();
          }
          showFinalStatus();
     }  //======================


     public abstract void askUsersFirstChoice();

     public abstract boolean shouldContinue();  

     public abstract void showUpdatedStatus();  

     public abstract void askUsersNextChoice();  


     public void showFinalStatus()  
     {    javax.swing.JOptionPane.showMessageDialog (null,
                         "That was right.  \nCongratulations.");
     }  //======================
}

public class Fraction extends Numeric
{
     /** A constant representing ZERO. */

     public static final Fraction ZERO = new Fraction (0, 1);
     /////////////////////////////////
     private int itsUpper;  // the numerator of the fraction
     private int itsLower;  // the denominator of the fraction


     /** Construct a Fraction from the given two integers. */

     public Fraction (int numerator, int denominator)
     {    if (numerator == 0 || denominator == 0)
          {    itsUpper = 0;
               itsLower = 1;
          }
          else if (denominator < 0)
          {    itsUpper = - numerator;
               itsLower = - denominator;
               this.reduceToLowestTerms();
          }
          else
          {    itsUpper = numerator;
               itsLower = denominator;
               this.reduceToLowestTerms();
          }
     }    //======================


     /** The parameter should be two ints separated by '/', e.g. 
      *  "2/3".  Return null if par is null or "".  Otherwise
      *  throw a NumberFormatException if the wrong form. */

     public Numeric valueOf (String par)
     {    if (par == null || par.length() == 0)
               return null;
          int k = 0;
          while (k < par.length() - 1 && par.charAt (k) != '/')
               k++;
          return new Fraction 
                       (Integer.parseInt (par.substring (0, k)),
                        Integer.parseInt (par.substring (k + 1)));
     }    //======================
     

     /** Express the Fraction as a String, e.g., "2/3". */

     public String toString()
     {    return this.itsUpper + "/" + this.itsLower;
     }    //======================


     /** Tell whether the two Fraction objects are equal. */

     public boolean equals (Object ob)
     {    return ob instanceof Fraction
                  && ((Fraction) ob).itsUpper == this.itsUpper
                  && ((Fraction) ob).itsLower == this.itsLower;
     }    //======================


     /** Return the sum of the executor and par. */

     public Numeric add (Numeric par)
     {    Fraction that = (Fraction) par;    // for simplicity
          return new Fraction (this.itsUpper * that.itsLower
                             + this.itsLower * that.itsUpper,
                               this.itsLower * that.itsLower);
     }    //======================


     /** Return the approximate value as a double value. */

     public double doubleValue()
     {    return itsUpper * 1.0 / itsLower;
     }    //======================


     /** Reduce the fraction to lowest terms.  Precondition:  the 
      *  denominator is positive and the numerator is non-zero. */

     private Fraction reduceToLowestTerms()
     {    divideOut (2);
          int limit = Math.min (Math.abs (itsUpper), itsLower);
          for (int divider = 3;  divider <= limit;  divider += 2)
               divideOut (divider);
          return this;
     }    //======================


     private void divideOut (int divider)
     {    while (itsUpper % divider == 0 && itsLower % divider == 0)
          {    itsUpper /= divider;
               itsLower /= divider;
          }
     }    //======================


     public int compareTo (Object ob)            
     //  Return the numerator of the result of subtracting this minus ob:
     {    return this.itsUpper * ((Fraction) ob).itsLower 
               - this.itsLower * ((Fraction) ob).itsUpper;
     }    //======================


     public Numeric subtract (Numeric par)         { return null; }

     public Numeric multiply (Numeric par)         { return null; }
}     

public class Complex extends Numeric
{
     public static final Complex ZERO = new Complex (0, 0);
     /////////////////////////////////
     private final double itsReal;
     private final double itsImag;


     public Complex (double realPart, double imagPart)
     {    itsReal = realPart;
          itsImag = imagPart;
     }    //======================


     public String toString ()
     {    String operator = itsImag < 0  ?  " "  :  " +";
          return itsReal + operator + itsImag + "i";
     }    //======================


     public double doubleValue()
     {    return itsReal;
     }    //======================


     public int compareTo (Object ob)
     {    double diff = this.itsReal - ((Complex) ob).itsReal;
          if (diff == 0)
               return 0;
          else
               return (diff > 0)  ?  1  :  -1;
     }    //======================


     public Numeric add (Numeric par)
     {    Complex that = (Complex) par;
          return new Complex (this.itsReal + that.itsReal,
                              this.itsImag + that.itsImag);
     }    //======================


     // the following are left as exercises
     public boolean equals (Object ob)
     {    return ob instanceof Complex 
                     && ((Complex) ob).itsReal == this.itsReal
                     && ((Complex) ob).itsImag == this.itsImag;
     }    //======================


     public Numeric multiply (Numeric par)
     {    Complex that = (Complex) par;
          return new Complex (this.itsReal * that.itsReal 
                         - this.itsImag * that.itsImag,
                           this.itsReal * that.itsImag 
                         + this.itsImag * that.itsReal);
     }    //======================


     public Numeric subtract (Numeric par)        {return ZERO;}

     public Numeric valueOf (String par)          {return ZERO;}
}     

public class VeryLong extends Numeric
{
     public static final VeryLong ZERO = new VeryLong (0, 0, 0);
     private static final int BILLION = 1000000000;
     private static final long LONGBILL = 1000000000L;
     private static final int MAX = 6;
     /////////////////////////////////
     private final int[] itsItem = new int[MAX];  // all zeros


     public VeryLong (long left, long mid, long right)
     {    this.itsItem[0] = (int) (left / LONGBILL);
          this.itsItem[1] = (int) (left % LONGBILL);
          this.itsItem[2] = (int) (mid / LONGBILL);
          this.itsItem[3] = (int) (mid % LONGBILL);
          this.itsItem[4] = (int) (right / LONGBILL);
          this.itsItem[5] = (int) (right % LONGBILL);
     }    //======================


     public String toString ()
     {    String s = "" + itsItem[0];
          for (int k = 1;  k < MAX;  k++)
               s += "," + ((BILLION + itsItem[k]) + "").substring(1);
          return s;
     }    //======================


     public Numeric add (Numeric par)
     {    VeryLong that = (VeryLong) par;
          VeryLong result = new VeryLong();
          for (int k = 0;  k < MAX;  k++)
               result.itsItem[k] = this.itsItem[k] + that.itsItem[k];
          for (int k = MAX - 1;  k > 0;  k--)
          {    if (result.itsItem[k] >= BILLION)
               {    result.itsItem[k] -= BILLION;
                    result.itsItem[k - 1]++;
               }
          }
          return result.itsItem[0] >= BILLION  ?  null  :  result;     
     }    //======================


     private VeryLong()     // only used by other VeryLong methods
     {    
     }    //======================
     

     public double doubleValue()
     {    double total = itsItem[0];
          for (int k = 1;  k < MAX;  k++)
               total = total * BILLION + itsItem[k];
          return total;
     }    //======================


     public boolean equals (Object ob)
     {    if (! (ob instanceof VeryLong))
               return false;
          VeryLong that = (VeryLong) ob;
          for (int k = 0;  k < MAX;  k++)
          {    if (this.itsItem[k] != that.itsItem[k])
                    return false;
          }
          return true;
     }    //======================


     public Numeric subtract (Numeric par)        {return ZERO;}

     public Numeric valueOf (String par)          {return ZERO;}

     public int compareTo (Object ob)             {return 0;   }

     public Numeric multiply (Numeric par)        {return ZERO;}
}     

/** Precondition:  if n is the number of values, they are 
 *  stored in components 0...n-1 and the other components 
 *  are null, and 0 <= n < length of array. */

public class NumericArray
{
     /** Tell whether target is a non-null value in the array. */

     public static boolean find (Object[ ] item, Object target)
     {    for (int k = 0;  item[k] != null;  k++)
          {    if (item[k].equals (target))
                    return true;
          }
          return false;
     }    //======================


     /** Return the sum of the values in the array; return null
      *  if the sum is not computable.  Precondition: 
      *  All non-null values are of the same Numeric type. */

     public static Numeric sum (Numeric[ ] item)
     {    if (item[0] == null)
               return null;
          Numeric total = item[0];
          for (int k = 1;  item[k] != null && total != null;  k++)
               total = total.add (item[k]);
          return total;
     }    //======================


     /** Print each non-null value on the screen. */

     public static void display (Object[ ] item)
     {    for (int k = 0;  item[k] != null;  k++)
               System.out.println (item[k].toString());
     }    //======================


     /** Return the array of values read from the source, to a 
      *  maximum of limit values.  Precondition: limit >= 0 and 
      *  data is the same Numeric subtype as all input values. */

     public static Numeric[ ] getInput (Numeric data, int limit, 
                              java.io.BufferedReader source) 
                       throws java.io.IOException
     {    Numeric[ ] item = new Numeric [limit + 1];  // all nulls
          for (int k = 0;  k < limit;  k++)
          {    item[k] = data.valueOf (source.readLine());
               if (item[k] == null)
                    return item;
          }
          return item;
     }    //======================


     // the following are from the exercises

     public static double sumValues (Numeric[ ] item)
     {    double valueToReturn = 0;
          for (int k = 0;  item[k] != null;  k++)
               valueToReturn += item[k].doubleValue();
          return valueToReturn;
     }    //======================


     public static int size (Object [ ] item) 
     {    int k = 0;
          while (item[k] != null)
               k++;
          return k;
     }    //======================


     public static boolean allSmall (Numeric[ ] item, Numeric par)
     {    for (int k = 0;  item[k] != null;  k++)
          {    if (item[k].compareTo (par) >= 0)
                    return false;
          }
          return true;
     }    //======================


     public static int indexSmallest (Numeric[ ] item)
     {    int valueToReturn = 0;
          for (int k = 1;  item[k] != null;  k++)
          {    if (item[k].compareTo (item[valueToReturn]) < 0)
                    valueToReturn = k;
          }
          return valueToReturn;
     }    //======================


     public static void delete (Object[ ] item, int n) 
     {    if (n >= 0 && n < item.length) 
          {    for ( ;  item[n] != null;  n++)
                    item[n] = item[n + 1];
          }
     }    //======================


     public static Numeric[] getComplexes (Numeric[ ] item)
     {    Numeric[ ] valueToReturn = new Numeric [item.length];
          int next = 0;
          for (int k = 0;  item[k] != null;  k++)
          {    if (item[k] instanceof Complex)
               {    valueToReturn[next] = item[k];
                    next++;
               }
          }
          return valueToReturn;
     }    //======================
}     

import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;

public class AddFromFile
{
     /** Read in up to 100 Fraction values from a file,
      *  then display them all on the screen with their sum. */

     public static void main (String[ ] args) throws IOException
     {    Numeric [ ] values = NumericArray.getInput 
                       (Fraction.ZERO, 100, new BufferedReader 
                              (new FileReader ("numeric.dat")));
          NumericArray.display (values);
          System.out.println ("Their sum is "
                              + NumericArray.sum (values));
     }    //======================
}     

public class ThreadOp
{
     public static boolean pause (int millis)
     {    try
          {    Thread.sleep (millis);
               return Thread.interrupted();
          }
          catch (InterruptedException e)
          {    return true;
          }
     }    //======================
}