PrintfFormat.java

/*
 * Class:        PrintfFormat
 * Description:
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author
 * @since
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package umontreal.ssj.util;
 
import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;
import java.util.Formatter;

public class PrintfFormat implements CharSequence, Appendable {
   private static NumberFormat nf = NumberFormat.getInstance(Locale.US);
   private static DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US);
   private static final int NDEC = 50;
   private static DecimalFormat[] dfe = new DecimalFormat[NDEC + 1];
   private static DecimalFormat[] dfg = new DecimalFormat[NDEC + 1];
   private StringBuffer sb;
   /*
    * private static void round (int b, StringBuffer num) { // round a real number
    * up if it is >= 0.5 // base is b
    * 
    * // round up the fractional part int j = num.length() - 1; String bm1 =
    * String.valueOf (b - 1); while (j >= 0 && num.charAt(j) == bm1.charAt(0)) {
    * num.deleteCharAt(j); j--; }
    * 
    * char c; if (j < 0) return; if (num.charAt(j) != '.') { c = num.charAt(j);
    * ++c; num.replace(j, j + 1, Character.toString(c)); return; }
    * 
    * // round up the integral part j--; while (j >= 0 && num.charAt(j) ==
    * bm1.charAt(0)) { num.replace(j, j + 1, "0"); j--; }
    * 
    * if (j < 0 || num.charAt(j) == '-') { num.insert( j + 1, '1'); } else if
    * (num.charAt(j) == ' ') { num.replace(j, j + 1, "1"); } else { c =
    * num.charAt(j); ++c; num.replace(j, j + 1, Character.toString(c)); } }
    */


   public static final String NEWLINE = System.getProperty("line.separator");

   public static final String LINE_SEPARATOR = System.getProperty("line.separator");


   public PrintfFormat() {
      sb = new StringBuffer();
   }

   public PrintfFormat(int length) {
      sb = new StringBuffer(length);
   }

   public PrintfFormat(String str) {
      sb = new StringBuffer(str);
   }

   public PrintfFormat append(String str) {
      sb.append(str);
      return this;
   }

   public PrintfFormat append(int fieldwidth, String str) {
      sb.append(s(fieldwidth, str));
      return this;
   }

   public PrintfFormat append(double x) {
      sb.append(x);
      return this;
   }

   public PrintfFormat append(int fieldwidth, double x) {
      sb.append(f(fieldwidth, x));
      return this;
   }

   public PrintfFormat append(int fieldwidth, int precision, double x) {
      sb.append(f(fieldwidth, precision, x));
      return this;
   }

   public PrintfFormat append(int x) {
      sb.append(x);
      return this;
   }

   public PrintfFormat append(int fieldwidth, int x) {
      sb.append(d(fieldwidth, x));
      return this;
   }

   public PrintfFormat append(long x) {
      sb.append(x);
      return this;
   }

   public PrintfFormat append(int fieldwidth, long x) {
      sb.append(d(fieldwidth, x));
      return this;
   }

   public PrintfFormat append(int fieldwidth, int accuracy, int precision, double x) {
      sb.append(format(fieldwidth, accuracy, precision, x));
      return this;
   }

   public PrintfFormat append(char c) {
      sb.append(c);
      return this;
   }

   public void clear() {
      sb.setLength(0);
   }

   public StringBuffer getBuffer() {
      return sb;
   }

   public String toString() {
      return sb.toString();
   }

   public static String s(String str) {
      if (str == null)
         return "null";
      else
         return str;
   }

   public static String s(int fieldwidth, String str) {
      if (str == null)
         return s(fieldwidth, "null");
 
      int fw = Math.abs(fieldwidth);
      if (str.length() < fw) {
         // We have to pad with spaces
         StringBuffer buf = new StringBuffer();
         int sl = str.length();
         for (int i = 0; i < fw - sl; i++)
            buf.append(' ');
         // Add the spaces before or after
         return fieldwidth >= 0 ? buf.toString() + str : str + buf.toString();
      } else
         return str;
   }


   public static String d(long x) {
      return d(0, 1, x);
   }

   public static String d(int fieldwidth, long x) {
      return d(fieldwidth, 1, x);
   }

   public static String d(int fieldwidth, int precision, long x) {
      if (precision < 0)
         throw new IllegalArgumentException("precision must " + "not be negative.");
      if (precision == 0 && x == 0)
         return s(fieldwidth, "");
 
      nf.setGroupingUsed(false);
      nf.setMinimumIntegerDigits(precision);
      nf.setMaximumFractionDigits(0); // will also set the min to 0
      return s(fieldwidth, nf.format(x));
   }

   public static String format(long x) {
      return d(0, 1, x);
   }

   public static String format(int fieldwidth, long x) {
      return d(fieldwidth, 1, x);
   }

   public static String formatBase(int b, long x) {
      return formatBase(0, b, x);
   }

   public static String formatBase(int fieldwidth, int b, long x) {
      boolean neg = false; // insert a '-' if true
      if (b < 2 || b > 10)
         throw new IllegalArgumentException("base must be between 2 and 10.");
 
      if (x < 0) {
         neg = true;
         x = -x;
      } else {
         if (x == 0)
            return "0";
 
         neg = false;
      }
      StringBuffer sb = new StringBuffer();
      while (x > 0) {
         sb.insert(0, x % b);
         x = x / b;
      }
      if (neg)
         sb.insert(0, '-');
      return s(fieldwidth, sb.toString());
   }



   public static String E(double x) {
      return E(0, 6, x);
   }

   public static String E(int fieldwidth, double x) {
      return E(fieldwidth, 6, x);
   }

   public static String E(int fieldwidth, int precision, double x) {
      if (precision < 0)
         throw new IllegalArgumentException("precision must " + "not be negative.");
      if (Double.isNaN(x))
         return s(fieldwidth, "NaN");
      if (Double.isInfinite(x))
         return s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
 
      DecimalFormat df;
      if (precision >= dfe.length || dfe[precision] == null) {
         // We need to create one pattern per precision value
         StringBuffer pattern = new StringBuffer("0.");
         for (int i = 0; i < precision; i++)
            pattern.append("0");
         pattern.append("E00");
         df = new DecimalFormat(pattern.toString(), dfs);
         df.setGroupingUsed(false);
         if (precision < dfe.length)
            dfe[precision] = df;
      } else
         df = dfe[precision];
      String res = df.format(x);
      // DecimalFormat doesn't add the + sign before the value of
      // the exponent.
      int exppos = res.indexOf('E');
      if (exppos != -1 && res.charAt(exppos + 1) != '-')
         res = res.substring(0, exppos + 1) + "+" + res.substring(exppos + 1);
      return s(fieldwidth, res);
   }

   public static String e(double x) {
      return e(0, 6, x);
   }

   public static String e(int fieldwidth, double x) {
      return e(fieldwidth, 6, x);
   }

   public static String e(int fieldwidth, int precision, double x) {
      String res = E(fieldwidth, precision, x);
      int exppos = res.indexOf('E');
      return exppos == -1 ? res : res.substring(0, exppos) + 'e' + res.substring(exppos + 1);
   }

   public static String f(double x) {
      return f(0, 6, x);
   }

   public static String f(int fieldwidth, double x) {
      return f(fieldwidth, 6, x);
   }

   public static String f(int fieldwidth, int precision, double x) {
      if (precision < 0)
         throw new IllegalArgumentException("precision must " + "not be negative.");
      if (Double.isNaN(x))
         return s(fieldwidth, "NaN");
      if (Double.isInfinite(x))
         return s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
 
      nf.setGroupingUsed(false);
      nf.setMinimumIntegerDigits(1);
      nf.setMinimumFractionDigits(precision);
      nf.setMaximumFractionDigits(precision);
      return s(fieldwidth, nf.format(x));
   }

   public static String G(double x) {
      return G(0, 6, x);
   }

   public static String G(int fieldwidth, double x) {
      return G(fieldwidth, 6, x);
   }

   public static String G(int fieldwidth, int precision, double x) {
      if (precision < 0)
         throw new IllegalArgumentException("precision must " + "not be negative.");
      if (precision == 0)
         precision = 1;
 
      if (Double.isNaN(x))
         return s(fieldwidth, "NaN");
      if (Double.isInfinite(x))
         return s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
 
      // Calculate the scientific notation format.
      // We cannot use E because it can make trailing zeros
      // that must be removed afterward.
      DecimalFormat df;
      if (precision >= dfg.length || dfg[precision] == null) {
         StringBuffer pattern = new StringBuffer("0.");
         for (int i = 0; i < (precision - 1); i++)
            pattern.append("#"); // Do not show trailing zeros
         pattern.append("E00");
         df = new DecimalFormat(pattern.toString(), dfs);
         df.setGroupingUsed(false);
         if (precision < dfg.length)
            dfg[precision] = df;
      } else
         df = dfg[precision];
      String res = df.format(x);
 
      int exppos = res.indexOf('E');
      if (exppos == -1)
         return res;
      int expval = Integer.parseInt(res.substring(exppos + 1));
      if (expval < -4 || expval >= precision) {
         // add the plus sign for the exponent if necessary.
         if (res.charAt(exppos + 1) != '-')
            return s(fieldwidth, res.substring(0, exppos + 1) + "+" + res.substring(exppos + 1));
         else
            return s(fieldwidth, res);
      }
 
      // Calculate the decimal notation format
      nf.setGroupingUsed(false);
      nf.setMinimumIntegerDigits(1);
      nf.setMinimumFractionDigits(0);
      // We need the number of digits after the decimal point to
      // to get precisions significant digits.
      // The integer part of x contains at most precision digits.
      // If that was not true, expval would be greater than precision.
      // If expval=0, we have a number of the form 1.234...
      // To have precisions significant digits, we need precision-1 digits.
      // If expval<0, x<1 and we need -expval additionnal
      // decimal digits.
      // If expval>0, we need less decimal digits.
      nf.setMaximumFractionDigits(precision - expval - 1);
      res = nf.format(x);
      return s(fieldwidth, res);
   }

   public static String g(double x) {
      return g(0, 6, x);
   }

   public static String g(int fieldwidth, double x) {
      return g(fieldwidth, 6, x);
   }

   public static String g(int fieldwidth, int precision, double x) {
      String res = G(fieldwidth, precision, x);
      int exppos = res.indexOf('E');
      return exppos == -1 ? res : res.substring(0, exppos) + 'e' + res.substring(exppos + 1);
   }

   public static String format(int fieldwidth, int accuracy, int precision, double x) {
      if (Double.isNaN(x))
         return s(fieldwidth, "NaN");
      if (Double.isInfinite(x))
         return s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
 
      if (canUseDecimalNotation(fieldwidth, accuracy, precision, x))
         return f(fieldwidth, accuracy, x);
      // Use scientific notation
      else {
         String S = E(fieldwidth, precision - 1, x);
         return processExp(S);
      }
   }
 
   private static boolean canUseDecimalNotation(int fieldwidth, int accuracy, int precision, double x) {
      // Le nombre de positions occupees par la partie entiere de x
      int PosEntier = 0;
      // Le nombre de chiffres significatifs avant le point
      int EntierSign;
      // La position de l'exposant dans le string S et la longueur de S
      int Neg = 0;
 
      if (x == 0.0)
         EntierSign = 1;
      else {
         EntierSign = PosEntier = (int) Math.floor(Math.log10(Math.abs(x)) + 1);
         if (x < 0.0)
            Neg = 1;
      }
      if (EntierSign <= 0)
         PosEntier = 1;
      return x == 0.0 || (((EntierSign + accuracy) >= precision) && (fieldwidth >= (PosEntier + accuracy + Neg + 1)));
   }
 
   private static int getMinAccuracy(double x) {
      if (Math.abs(x) >= 1 || x == 0)
         return 0;
      else
         return -(int) Math.floor(Math.log10(Math.abs(x)));
   }
 
   private static String processExp(String s) {
      int p = s.indexOf("E+0");
      if (p == -1)
         p = s.indexOf("E-0");
 
      // remove the 0 in E-0 and in E+0
      if (p != -1)
         s = " " + s.substring(0, p + 2) + s.substring(p + 3);
 
      p = s.indexOf(".E");
      if (p != -1)
         s = " " + s.substring(0, p) + s.substring(p + 1);
      return s;
   }

   public static String format(Locale locale, int fieldwidth, int accuracy, int precision, double x) {
      Formatter fmt = new Formatter(locale);
      if (Double.isNaN(x))
         return fmt.format("%" + fieldwidth + "s", "NaN").toString();
      if (Double.isInfinite(x))
         return fmt.format("%" + fieldwidth + "s", (x < 0 ? "-" : "") + "Infinite").toString();
 
      if (canUseDecimalNotation(fieldwidth, accuracy, precision, x))
         return fmt.format("%" + fieldwidth + "." + accuracy + "f", x).toString();
      // Use scientific notation
      else {
         String S = fmt.format("%" + fieldwidth + "." + (precision - 1) + "E", x).toString();
         return processExp(S);
      }
   }

   public static String formatBase(int fieldwidth, int accuracy, int b, double x) {
      if (Double.isNaN(x))
         return s(fieldwidth, "NaN");
      if (Double.isInfinite(x))
         return s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
      if (0. == x || -0. == x)
         return s(fieldwidth, "0");
      if (Math.abs(x) >= Num.TWOEXP[63])
         throw new UnsupportedOperationException("   |x| >= 2^63");
 
      long n = (long) x;
      String mant = formatBase(-1, b, n);
      if (n == x)
         return s(fieldwidth, mant);
      if (n == 0) {
         if (x < 0) {
            mant = "-0";
         } else
            mant = "0";
      }
      // round before printing
      if (x > 0)
         x += 0.5 * Math.pow(b, -accuracy - 1);
      else if (x < 0)
         x -= 0.5 * Math.pow(b, -accuracy - 1);
      x -= n;
      if (x < 0)
         x = -x;
 
      StringBuffer frac = new StringBuffer(".");
      long y;
      int j;
      for (j = 0; j < accuracy; ++j) {
         x *= b;
         y = (long) x;
         frac.append(y);
         x -= y;
         if (x == 0.)
            break;
      }
 
      StringBuffer number = new StringBuffer(mant);
      number.append(frac);
 
      // remove trailing spaces and 0
      j = number.length() - 1;
      while (j > 0 && (number.charAt(j) == '0' || number.charAt(j) == ' ')) {
         number.deleteCharAt(j);
         j--;
      }
 
      return s(fieldwidth, number.toString());
   }
 
   // Interface CharSequence
   public char charAt(int index) {
      return sb.charAt(index);
   }
 
   public int length() {
      return sb.length();
   }
 
   public CharSequence subSequence(int start, int end) {
      return sb.subSequence(start, end);
   }
 
   // Interface Appendable
   public Appendable append(CharSequence csq) {
      return sb.append(csq);
   }
 
   public Appendable append(CharSequence csq, int start, int end) {
      return sb.append(csq, start, end);
   }



   public static void formatWithError(int fieldwidth, int fieldwidtherr, int accuracy, int precision, double x,
         double error, String[] res) {
      if (res.length != 2)
         throw new IllegalArgumentException("The given res array must contain two elements");
      if (Double.isNaN(x)) {
         res[0] = s(fieldwidth, "NaN");
         res[1] = s(fieldwidtherr, "");
         return;
      }
      if (Double.isInfinite(x)) {
         res[0] = s(fieldwidth, (x < 0 ? "-" : "") + "Infinite");
         res[1] = s(fieldwidtherr, "");
         return;
      }
      if (accuracy < 0)
         accuracy = 0;
 
      if (canUseDecimalNotation(fieldwidth, accuracy, precision, x)) {
         res[0] = f(fieldwidth, accuracy, x);
         res[1] = f(fieldwidtherr, accuracy, error);
      }
      // Use scientific notation
      else {
         res[0] = processExp(E(fieldwidth, precision - 1, x));
         int xExp = x == 0 ? 0 : (int) Math.floor(Math.log10(Math.abs(x)));
         int errorExp = error == 0 ? 0 : (int) Math.floor(Math.log10(Math.abs(error)));
         int errorPrecision = precision - 1 - (xExp - errorExp);
         if (errorPrecision < 0)
            errorPrecision = 0;
         res[1] = processExp(E(fieldwidtherr, errorPrecision, error));
      }
   }

   public static void formatWithError(int fieldwidth, int fieldwidtherr, int precision, double x, double error,
         String[] res) {
      int accuracy = getMinAccuracy(error);
      if (!canUseDecimalNotation(fieldwidth, accuracy, precision, x)) {
         int posEntier = (int) Math.floor(Math.log(Math.abs(x)) / Math.log(10) + 1);
         if (posEntier < 0)
            posEntier = 1;
         int newAccuracy = precision - posEntier;
         if (canUseDecimalNotation(fieldwidth, newAccuracy, precision, x))
            accuracy = newAccuracy;
      }
      formatWithError(fieldwidth, fieldwidtherr, accuracy, precision, x, error, res);
   }

   public static void formatWithError(Locale locale, int fieldwidth, int fieldwidtherr, int accuracy, int precision,
         double x, double error, String[] res) {
      if (res.length != 2)
         throw new IllegalArgumentException("The given res array must contain two elements");
      Formatter fmt = new Formatter(locale);
      Formatter fmtErr = new Formatter(locale);
      if (Double.isNaN(x)) {
         res[0] = fmt.format("%" + fieldwidth + "s", "NaN").toString();
         res[1] = fmtErr.format("%" + fieldwidtherr + "s", "").toString();
         return;
      }
      if (Double.isInfinite(x)) {
         res[0] = fmt.format("%" + fieldwidth + "s", (x < 0 ? "-" : "") + "Infinite").toString();
         res[1] = fmtErr.format("%" + fieldwidtherr + "s", "").toString();
         return;
      }
      if (accuracy < 0)
         accuracy = 0;
 
      if (canUseDecimalNotation(fieldwidth, accuracy, precision, x)) {
         res[0] = fmt.format("%" + fieldwidth + "." + accuracy + "f", x).toString();
         res[1] = fmtErr.format("%" + fieldwidtherr + "." + accuracy + "f", error).toString();
      }
      // Use scientific notation
      else {
         res[0] = processExp(fmt.format("%" + fieldwidth + "." + (precision - 1) + "E", x).toString());
         int xExp = x == 0 ? 0 : (int) Math.floor(Math.log10(Math.abs(x)));
         int errorExp = error == 0 ? 0 : (int) Math.floor(Math.log10(Math.abs(error)));
         int errorPrecision = precision - 1 - (xExp - errorExp);
         if (errorPrecision < 0)
            errorPrecision = 0;
         res[1] = processExp(fmtErr.format("%" + fieldwidtherr + "." + errorPrecision + "E", error).toString());
      }
   }

   public static void formatWithError(Locale locale, int fieldwidth, int fieldwidtherr, int precision, double x,
         double error, String[] res) {
      int accuracy = getMinAccuracy(error);
      if (!canUseDecimalNotation(fieldwidth, accuracy, precision, x)) {
         int posEntier = (int) Math.floor(Math.log(Math.abs(x)) / Math.log(10) + 1);
         if (posEntier < 0)
            posEntier = 1;
         int newAccuracy = precision - posEntier;
         if (canUseDecimalNotation(fieldwidth, newAccuracy, precision, x))
            accuracy = newAccuracy;
      }
      formatWithError(locale, fieldwidth, fieldwidtherr, accuracy, precision, x, error, res);
   }
 
}