import java.awt.*;
import java.util.*;
import java.lang.*;
import java.text.*;

public class NumFormat{
   //Define symbolic constants for use in switch statements 
   //(Gosling 5, 142).
    private static final int intType=0, doubleType=1;
    private static final String PlusSign="+", MinusSign="-";
    private static final int Izero=0;
    private static final int Ione=1;
//    private static final int Idelta=1e-99;
    private static final double zero=0.0e0;
    private static final double one=1.0e0;
    private static final double ten=10.0e0;
    private static final double delta=1.0e-99;
    //Emulate some constants from Double class.
    private static final double MAX_VALUE=1.0e99;
    private static final double MIN_VALUE=-1.0e99;
    private static final String POSITIVE_INFINITY="Infinity";
    private static final String NEGATIVE_INFINITY="-Infinity";
    private static final String POSITIVE_ZERO="0";
    private static final String NEGATIVE_ZERO="-0";
 
    private String strZero=null, strLimit=null;
    private int Type;
    private int FieldLength, Ndecimals, NExpDigits, IntDigits;
    private Hashtable AllowedTypes, Conversion;
    private String strValue, SignOfNumber, strExponent=null;
    private int IExponent;
    private boolean hasExponent=false, forceExponent=false,
                    incrementExponent=false, forceRightPadding=false;
    private Util util;

    NumFormat(int FieldLength, int Ndecimals){
        setFieldLength(FieldLength);
        setFractionDigits(Ndecimals);
        setExponentDigits(2);
        setIntegerDigits(1);
        setForceExponent(false);
        setForceRightPadding(false);
        setup();
    }
    NumFormat(){
        setFieldLength(15);
        setFractionDigits(5);
        setExponentDigits(2);
        setIntegerDigits(1);
        setForceExponent(false);
        setForceRightPadding(false);
        setup();
    }
    public void setup()
    {
        util = new Util();
        AllowedTypes = new Hashtable();
        AllowedTypes.put("integer", new Integer(0) );
        AllowedTypes.put("double", new Integer(1) );
        Conversion = new Hashtable();
        Conversion.put("0", new Integer(0) );
        Conversion.put("1", new Integer(1) );
        Conversion.put("2", new Integer(2) );
        Conversion.put("3", new Integer(3) );
        Conversion.put("4", new Integer(4) );
        Conversion.put("5", new Integer(5) );
        Conversion.put("6", new Integer(6) );
        Conversion.put("7", new Integer(7) );
        Conversion.put("8", new Integer(8) );
        Conversion.put("9", new Integer(9) );
    }
    public void setType(String str)
    {
        Integer n = (Integer)AllowedTypes.get(str);
        Type = n.intValue();
    }
    public int getType()
    {
        return(Type);
    }
    public void setForceExponent(boolean forceExp)
    {
        forceExponent = forceExp;
    }
    public void setFieldLength(int value)
    {
        FieldLength = value;
    }
    public void setFractionDigits(int value)
    {
        Ndecimals = value;
    }
    public void setIntegerDigits(int value)
    {
        IntDigits = value;
    }
    public void setExponentDigits(int value)
    {
        NExpDigits = value;
    }
    public void setForceRightPadding(boolean forceRightPadding)
    {
        this.forceRightPadding = forceRightPadding;
    }
    //Return an integer representation preceded by a maximum of
    //IntDigits '0's and a total lenght of FieldLength.
    public String format(int value)
    {
        String theSign = Sign(value);
        Integer Ivalue = new Integer(value);
        String S1 = Ivalue.toString();
        String S2 = stripSign(S1);
        S1 = LeftPad(S2, '0', IntDigits);
        if(theSign.compareTo(MinusSign) == 0){
            S2 = addSign(S1, theSign);
        }else{
            S2 = S1;
        }
        S1 = LeftPad(S2, ' ', FieldLength);
        return(S1);
    }
    public String format(double value)
    {
        String strNum=null;
        if(isZero(value))return(strZero);
        if(isBigOrSmall(value))return(strLimit);
        SignOfNumber = Sign(value);
        if(!forceExponent)strNum = numField(value);
        if( forceExponent)strNum = expoField(value);
        return(strNum);
    }
    //Return a floating-point representation occupying a field length
    //of FieldLength, forcing inclusion of the exponential part.
    public String expoField(double value)
    {
        double Value, val;
        String S1, S2;
        int power;

        hasExponent = true;
        Value = Math.abs(value);
        power = util.Ilog10(Value);
        if(power == Izero){
            val = Value;
        }else{
            val = Value / Math.pow(ten, (double)power);
        }
        //This condition insures that the floating-point representation
        //(preceding the exponent) will begin with "digit.mmmmm..."
        //with digit != 0 when abs(value) < 1.

        if(Value <one && val <one){
/*
         System.out.println("1value = " +value + " val = " +val 
                           +" power = " +power);
*/
            val *= ten;
            power -= Ione;
/*
         System.out.println("2value = " +value + " val = " +val 
                           +" power = " +power);
*/
        }
        IExponent = power;
        Double Dnum = new Double(val);
        String str = Dnum.toString();
        S1 = str;
        //This implies that RoundOff should return immediately, and
        //the exponent will not be incremented later. We must take
        //care of this possibility otherwise the representation will
        //end up with more than one digit preceeding the decimal point
        //(namely, "10"), which we are trying to avoid here.
        if(S1.compareTo("10") == 0){ 
            S1 = "1"; IExponent++;
        }
        S2 = AddZero(S1);
        //If there already is a dot, but less than Ndecimals following
        //it, then this call does nothing and we're stuck with less
        //than Ndecimals at the end. E.g. Netscape always follows a dot
        //with at least 1 digit only. The equivalent representation in
        //Explorer may not contain the dot, in which case the rest of
        //the field *will* be filled.
        S1 = AddDot(S2, Ndecimals);
        S2 = RoundOff(S1, Ndecimals);
        if(SignOfNumber.compareTo(MinusSign) == 0){
            S1 = addSign(S2, SignOfNumber);
        }else{
            S1 = S2;
        }
        if(incrementExponent)IExponent++;
        strExponent = BuildExponent(IExponent, NExpDigits);
        S2 = S1.concat(strExponent);
        S1 = LeftPad(S2, ' ', FieldLength);
        return(S1);
    }    
    //Return a floating-point representation occupying a field length
    //of FieldLength. The string representation is let to conform with
    //the particular JRE: It may or may not contain an exponential part.
    public String numField(double value)
    {
        String S1, S2;

        Double Dnum = new Double(value);
        String str = Dnum.toString();
        DecomposeFloat(str);
        S1 = strValue;
        S2 = stripSign(S1);
        S1 = AddZero(S2);
        S2 = AddDot(S1, Ndecimals);
        if(forceRightPadding){
            S1 = rightPadWithZeros(S2, Ndecimals);
        }else{
            S1 = S2;
        }
        S2 = RoundOff(S1, Ndecimals);
        if(SignOfNumber.compareTo(MinusSign) == 0){
            S1 = addSign(S2, SignOfNumber);
        }else{
            S1 = S2;
        }
        if(hasExponent){
            IExponent = StringToInt(strExponent);
            if(incrementExponent)IExponent++;
            strExponent = BuildExponent(IExponent, NExpDigits);
            S2 = S1.concat(strExponent);
        }else{
            S2 = S1;
        }
        S1 = LeftPad(S2, ' ', FieldLength);
        return(S1);
    }
    //Return the sign of a double value, as a string.
    public String Sign(double value)
    {
        String theSign;

        if(value >= zero){
            theSign = PlusSign;
        }else{
            theSign = MinusSign;
        }
        return(theSign);
    }
    //Return the sign of an integer value, as a string.
    public String Sign(int value)
    {
        String theSign;

        if(value >= Izero){
            theSign = PlusSign;
        }else{
            theSign = MinusSign;
        }
        return(theSign);
    }
    //Assess if a value can be equated to +-Infinity.
    public boolean isBigOrSmall(double value)
    {
        String string;
        if(value < MIN_VALUE || value > MAX_VALUE){
            if(value <MIN_VALUE){
                string = NEGATIVE_INFINITY;
            }else{
                string = POSITIVE_INFINITY;
            }
            strLimit = LeftPad(string, ' ', FieldLength);
            return(true);
        }
        return(false);
    }
    //Assess if a value can be equated to zero.
    public boolean isZero(double value)
    {
        String S1=null, S2=null;
        double absValue = Math.abs(value);
        if(absValue < delta){
            if(value < zero){
                S1=NEGATIVE_ZERO;
            }else{
                S1=POSITIVE_ZERO;
            }
            S2 = AddDot(S1, Ndecimals);
            if(forceExponent){
                strExponent = BuildExponent(Izero, NExpDigits);
                S1 = S2.concat(strExponent);
            }else{
                S1 = S2;
            }
            strZero = LeftPad(S1, ' ', FieldLength);
            return(true);
        }
        return(false);
    }
    //Return the Exponential representation. The integer part is
    //made to occupy a field length of 'Ifield', with '0' padding
    //to the left (e.g., '03' of 'E+03' has Ifield=2).
    public String BuildExponent(int value, int Ifield)
    {
        String string, str, theSign, expo="E";
        
        theSign = Sign(value);
        Integer Ivalue = new Integer(value);
        string = Ivalue.toString();
        str = stripSign(string);
        string = LeftPad(str, '0', Ifield);
        str = addSign(string, theSign);
        string = expo.concat(str);
        return(string);
    }    
    //Return the leading sign associated with a string, null if absent.
    //Here we're assuming that a sign is located at index 0 of the string.
    public String getSign(String string)
    {
        int i;  char charSign[]={'-', '+'};
        Character CharSign=null; String theSign=null;

        for(i=0; i<charSign.length; i++){
            if(string.indexOf(charSign[i]) == 0){
                CharSign = new Character(charSign[i]);
                theSign = CharSign.toString();
            }
        }
        return(theSign);
    }
    //Assess if a string contains a leading sign.
    public boolean isSigned(String string)
    {
        if(getSign(string) != null){
            return(true);
        }else{
            return(false);
        }
    }
    //Add a sign to a string if it does not already have one.
    public String addSign(String string, String strSign)
    {
        String newStr, theSign;

        if(!isSigned(string)){
            newStr = strSign.concat(string);
        }else{
            newStr = string;
        }
        return(newStr);
    }    
    //Strip a string of it's leading sign if it contains one.
    public String stripSign(String string)
    {
        int Len; String newStr; char CharStr[];

        Len = string.length();
        if(isSigned(string)){
            CharStr = string.toCharArray();
            newStr = String.copyValueOf(CharStr, 1, Len-1);
        }else{
            newStr = string;
        }
        return(newStr);
    }
    //Decompose a floating-poing representation into it's value
    //(preceeding it's exponent) and it's exponent.
    public void DecomposeFloat(String str)
    {
        int n, Len;
        String string, newStr, strExp;
        char Exponent='e', CharStr[];
        
        string = str.toLowerCase();
        Len = string.length();
        n = string.indexOf(Exponent);
        if(n != -1){
            hasExponent = true;
            CharStr = string.toCharArray();
            strValue  = String.copyValueOf(CharStr, 0, n);
            strExponent = String.copyValueOf(CharStr, n+1, Len-n-1);
        }else{
            strValue = string;
            hasExponent = false;
            strExponent=null;
        }        
    }
    //Left-Pad a string with character 'Ichar' so that it has a
    //length of Ifield.
    public String LeftPad(String string, char Ichar, int IField)
    {
        int i, Len, delta;
        String newStr, str; char CharStr[];

        Len = string.length();
        if(Len >= IField){
            newStr = string;
            return(newStr);
        }
        delta = IField - Len;
        CharStr = new char[delta];
        for(i=0; i<delta; i++)CharStr[i] = Ichar;
        str = String.copyValueOf(CharStr);
        newStr = str.concat(string);
        return(newStr);
    }
    //If the first character of a floating-point representation
    //is a dot, precede it with a zero.
    public String AddZero(String string)
    {
        int n;
        String newString, strZero="0";

        n = string.indexOf('.');
        if(n == -1 || n != 0){
            newString = string;
            return(newString);
        }
        newString = strZero.concat(string);
        return(newString);
    }
    //Add a dot at the end of a string only if it does not
    //contain one already.
    public String AddDot(String string)
    {
        String newStr; int n;

        n = string.indexOf('.');
        if(n == -1){
            newStr = string.concat(".");
        }else{
            newStr = string;
        }        
        return(newStr);
    }
    //If the representation of a floating-point value does not
    //contain a dot, i.e. resembles an integer, add a dot at
    //the end followed by Ipad zero's.
    public String AddDot(String string, int Ipad)
    {
        int n;
        String str1, str2, newStr=null; char CharStr[];

        n = string.indexOf('.');
        if(n == -1){
            str1 = string.concat(".");
        }else{
            newStr = string;
            return(newStr);
        }
        CharStr = new char[Ipad];
        for(n=0; n<Ipad; n++)CharStr[n] = '0';
        str2 = String.copyValueOf(CharStr);
        newStr = str1.concat(str2);
        return(newStr);
    }
    //Pad a floating-point representation with 0's to the right of
    //the decimal point so that the total number of decimals is Ipad.
    //N.B.: This padding may not be significant.
    public String rightPadWithZeros(String string, int Ipad)
    {
        int i, n, Len, dotIndex, NdecimalPoints;
        String str1, str2, newStr=null; char CharStr[];

        dotIndex = string.indexOf('.');
        if(dotIndex == -1){
            newStr = string;
            return(newStr);
        }
        str1 = string;
        Len = string.length();
        NdecimalPoints = Len - 1 - dotIndex;
        if(NdecimalPoints >= Ipad)return(str1);
        n = Ipad - NdecimalPoints; //Number of 0's to fill in
        CharStr = new char[n];
        for(i=0; i<n; i++)CharStr[i] = '0';
        str2 = String.copyValueOf(CharStr);
        newStr = str1.concat(str2);
        return(newStr);
    }
    //Truncate a string representing a floating-point value to
    //Ipad decimal points. This algorithm assumes that one or 
    //more digits are already to the left of the decimal point.
    public String RoundOff(String str, int Ipad)
    {
        int i, dotIndex, theIndex, Len, newLen, I, Inext, Iround,
            Istart; 
        char CharStr[], newCharStr[]; 
        String string, Left, Right, newStr=null, strZero="0",
               strDot=".";
        incrementExponent=false; //Must initialize this when entering.
        
        dotIndex = str.indexOf('.');
        Len = str.length();
        if( (Len-dotIndex-1) <= Ipad){   //The representation has less
            newStr = str;                //significant digits than Ipad,
            return(newStr);              //so just return.
        }
        theIndex = dotIndex + Ipad;      //The index of the last
                                         //significant digit.
        newLen = theIndex + 1;           //Length of the rounded number.
        CharStr = str.toCharArray();

      //This function is not compatible with Explorer 3.0.  
      //I     = Character.getNumericValue(CharStr[theIndex  ]);
      //Inext = Character.getNumericValue(CharStr[theIndex+1]);
        I     = CharToDigit(CharStr[theIndex  ]);
        Inext = CharToDigit(CharStr[theIndex+1]);

                         //Truncation with no rounding-off
        if(Inext <5){
            newStr = String.copyValueOf(CharStr, 0, newLen);
            return(newStr);
        }
                         //Truncation with rounding-off of
                         //the last significant digit only.
        if(Inext >= 5 && I != 9){
            I++;                        //I is the rounded digit.
            newStr = String.copyValueOf(CharStr, 0, newLen);
            newCharStr = newStr.toCharArray();
            char ch = DigitToChar(I);
            newCharStr[theIndex] = ch;  //Insert the rounded digit.
            newStr = String.copyValueOf(newCharStr);
            return(newStr);
        }
                         //Truncation with rounding-off of
                         //additional significant digits.
        //Precede representation by a zero in case rounding affects
        //digits to the left of the decimal point. 
        string = strZero.concat(str); dotIndex++; Len++;
        CharStr = string.toCharArray();

        //Split the fields left and right of the decimal point.
        Left  = String.copyValueOf(CharStr, 0, dotIndex);
        Right = String.copyValueOf(CharStr, dotIndex+1, Len-dotIndex-1);

        //Now join these fields so that string refers to the 
        //representation stripped of the decimal point. This
        //relieves us of the burden of taking into account the
        //position of the decimal point in what follows.
        string = Left.concat(Right);
        Len--;                     //The length of the (stripped) string;
        theIndex = dotIndex - 1 + Ipad; //The index of the last 
                                        //significant digit of string.
        newLen = theIndex + 1;          //Length of the rounded string.

        //First, copy original (stripped) string to newStr
        CharStr = string.toCharArray();
        newStr = String.copyValueOf(CharStr, 0, newLen);

        //Next, substitute appropriate "numbers" in the character
        //representation of newStr.
        newCharStr = newStr.toCharArray();
        newCharStr[theIndex] = DigitToChar(0);
        for(i=theIndex-1; i>=0; i--){
            I = CharToDigit(CharStr[i]);
            if(I < 9){
                newCharStr[i] = DigitToChar(++I);
                break;
            }
            newCharStr[i] = DigitToChar(0);
        }
        //When i=0, we've substituted the added leading '0' by a '1'.
        //If the representation contains an exponent, we will have 
        //to shift the decimal point one position to the left and also
        //increment the value of the exponent by 1.
        if(i == 0){ 
            Istart = 0;
            if(hasExponent)incrementExponent = true;
        }else{
            Istart = 1;
        }
        //Split the resulting rounded "number" in 2 fields: one 
        //for the field to the left of the decimal point; the other 
        //for the field to the right of the decimal point.
        //
        //Round-off has produced a first digit '1' where we previously
        //had placed a '0'. If the representation contains an exponent,
        //we shift the decimal point one position to the left. Following
        //this we will have to increment the value of the exponent by 1.
        if(incrementExponent){
            Left = String.copyValueOf(newCharStr, 0, dotIndex-1);
            Right = String.copyValueOf(newCharStr, dotIndex-1, Ipad);
        }else{
            Left = String.copyValueOf(newCharStr, Istart, dotIndex-Istart);
            Right = String.copyValueOf(newCharStr, dotIndex, Ipad);
        }
        //Now add the decimal point and return resulting rounded 
        //floating-point representation.
        str = Left.concat(strDot);
        newStr = str.concat(Right);
        return(newStr);
    }
    //Convert a character - representing an integer - to the 
    //corresponding integer value.
    public int CharToDigit(char value)
    {
        String str = CharToString(value);
        Integer n = (Integer)Conversion.get(str);
        return(n.intValue());
    }
    //Convert a character to a string.
    public String CharToString(char value){
        String string; char Charvec[];

        Charvec = new char[1];
        Charvec[0] = value;
        string = String.copyValueOf(Charvec);
        return(string);
    }
    //Convert an integer value to it's corresponding
    //character representation.
    public char DigitToChar(int value){
        Integer Ivalue; String str; char CharStr[];

        Ivalue = new Integer(value);
        str = Ivalue.toString();
        CharStr = str.toCharArray();
        return(CharStr[0]);
    }
    //Convert a string to it's corresponding integer value.
    public int StringToInt(String string)
    {
        String sgn = getSign(string);
        String str = stripSign(string);
        Integer Ivalue = new Integer(str);
        int value = Ivalue.intValue();
        //Restore the sign.
        if(sgn != null){
            if(sgn.compareTo(MinusSign) == 0)value = -value;
        }
        return(value);
    }
}