package nom.tam.util;
   
   /*
    * #%L
    * nom.tam FITS library
    * %%
    * Copyright (C) 2004 - 2024 nom-tam-fits
    * %%
    * This is free and unencumbered software released into the public domain.
   *
   * Anyone is free to copy, modify, publish, use, compile, sell, or
   * distribute this software, either in source code form or as a compiled
   * binary, for any purpose, commercial or non-commercial, and by any
   * means.
   *
   * In jurisdictions that recognize copyright laws, the author or authors
   * of this software dedicate any and all copyright interest in the
   * software to the public domain. We make this dedication for the benefit
   * of the public at large and to the detriment of our heirs and
   * successors. We intend this dedication to be an overt act of
   * relinquishment in perpetuity of all present and future rights to this
   * software under copyright law.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
   * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
   * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
   * OTHER DEALINGS IN THE SOFTWARE.
   * #L%
   */
  
  /**
   * This class provides mechanisms for efficiently formatting numbers and Strings. Data is appended to existing byte
   * arrays. Note that the formatting of real or double values may differ slightly (in the last bit) from the standard
   * Java packages since this routines are optimized for speed rather than accuracy.
   * <p>
   * The methods in this class create no objects.
   * <p>
   * If a number cannot fit into the requested space the truncateOnOverlow flag controls whether the formatter will
   * attempt to append it using the available length in the output (a la C or Perl style formats). If this flag is set, or
   * if the number cannot fit into space left in the buffer it is 'truncated' and the requested space is filled with a
   * truncation fill character. A TruncationException may be thrown if the truncationThrow flag is set.
   * <p>
   * This class does not explicitly support separate methods for formatting reals in exponential notation. Real numbers
   * near one are by default formatted in decimal notation while numbers with large (or very negative) exponents are
   * formatted in exponential notation. By setting the limits at which these transitions take place the user can force
   * either exponential or decimal notation.
   * 
   * @deprecated This class should not be exposed in the public API and is intended for internal use only in ASCII tables.
   *                 Also, it may have overlapping functionality with other classes, which should probably be eliminated
   *                 for simplicity's sake (and thus less chance of nasty bugs).
   * 
   * @see        ByteParser
   */
  @Deprecated
  public final class ByteFormatter {
  
      /** String representation of NaN values */
      public static final String NOT_A_NUMBER = "NaN";
  
      /** String representation of (positive) infinity values */
      public static final String INFINITY = "Infinity";
  
      /** String representation of (negative) infinity values */
      public static final String NEGATIVE_INFINITY = "-Infinity";
  
      /**
       * Maximum magnitude to print in non-scientific notation.
       */
      private static final double DEFAULT_SIMPLE_MAX = 1.e6;
  
      /**
       * Minimum magnitude to print in non-scientific notation.
       */
      private static final double DEFAULT_SIMPLE_MIN = 1.e-3;
  
      /**
       * Digits. We could handle other bases by extending or truncating this list and changing the division by 10 (and
       * it's factors) at various locations.
       */
      private static final byte[] DIGITS = {(byte) '0', (byte) '1', (byte) '2', (byte) '3', (byte) '4', (byte) '5',
              (byte) '6', (byte) '7', (byte) '8', (byte) '9'};
  
      private static final long DOUBLE_EXPONENT_BIT_MASK = 0x7FF0000000000000L;
  
      private static final int DOUBLE_EXPONENT_EXCESS = 52;
  
      /**
       * The hidden bit in normalized double numbers.
       */
      private static final long DOUBLE_EXPONENT_NORMALIZE_BIT = 0x0010000000000000L;
  
      /**
       * Used to check if double is normalized
       */
      private static final int DOUBLE_MIN_EXPONENT = -1023;
  
     private static final int DOUBLE_SHIFT_BASE = 17;
 
     private static final int DOUBLE_SHIFT_LIMIT = 200;
 
     private static final long DOUBLE_VALUE_BIT_MASK = 0x000FFFFFFFFFFFFFL;
 
     private static final int FLOAT_EXPONENT_BIT_MASK = 0x7F800000;
 
     private static final int FLOAT_EXPONENT_EXCESS = 23;
 
     /**
      * The hidden bit in normalized floating point numbers.
      */
     private static final int FLOAT_EXPONENT_NORMALIZE_BIT = 0x00800000;
 
     /**
      * Used to check if float is normalized
      */
     private static final int FLOAT_MIN_EXPONENT = -127;
 
     private static final int FLOAT_SHIFT_BASE = 8;
 
     private static final int FLOAT_SHIFT_LIMIT = 30;
 
     private static final int FLOAT_VALUE_BIT_MASK = 0x007FFFFF;
 
     private static final double I_LOG_10 = 1. / Math.log(ByteFormatter.NUMBER_BASE);
 
     private static final long LONG_TO_INT_MODULO = 1000000000L;
 
     private static final int MAX_LONG_LENGTH = 19;
 
     /**
      * The maximum single digit integer. Special case handling when rounding up and when incrementing the exponent.
      */
 
     private static final int MAXIMUM_SINGLE_DIGIT_INTEGER = 9;
 
     /**
      * The maximum two digit integer. When we increment an exponent of this value, the exponent gets longer. Don't need
      * to worry about 999 since exponents can't be that big.
      */
     private static final int MAXIMUM_TWO_DIGIT_INTEGER = 99;
 
     private static final int TEMP_BUFFER_SIZE = 32;
 
     /**
      * The underlying number base used in this class.
      */
     private static final int NUMBER_BASE = 10;
 
     /**
      * Powers of 10. We over extend on both sides. These should perhaps be tabulated rather than computed though it may
      * be faster to calculate them than to read in the extra bytes in the class file.
      */
     private static final double[] NUMBER_BASE_POWERS;
 
     /**
      * What do we use to fill when we cannot print the number?Default is often used in Fortran.
      */
     private static final byte TRUNCATION_FILL = (byte) '*';
 
     /**
      * What index of tenpow is 10^0
      */
     private static final int ZERO_POW;
 
     static { // Static initializer
         int min = (int) Math.floor((int) (Math.log(Double.MIN_VALUE) * ByteFormatter.I_LOG_10));
         int max = (int) Math.floor((int) (Math.log(Double.MAX_VALUE) * ByteFormatter.I_LOG_10));
         max++;
         NUMBER_BASE_POWERS = new double[max - min + 1];
         for (int i = 0; i < ByteFormatter.NUMBER_BASE_POWERS.length; i++) {
             ByteFormatter.NUMBER_BASE_POWERS[i] = Math.pow(ByteFormatter.NUMBER_BASE, i + min);
         }
         ZERO_POW = -min;
     }
 
     /**
      * Internal buffers used in formatting fields
      */
     private final byte[] tbuf1 = new byte[ByteFormatter.TEMP_BUFFER_SIZE];
 
     private final byte[] tbuf2 = new byte[ByteFormatter.TEMP_BUFFER_SIZE];
 
     /**
      * This method formats a double given a decimal mantissa and exponent information.
      *
      * @param  val   The original number
      * @param  buf   Output buffer
      * @param  off   Offset into buffer
      * @param  len   Maximum number of characters to use in buffer.
      * @param  mant  A decimal mantissa for the number.
      * @param  lmant The number of characters in the mantissa
      * @param  shift The exponent of the power of 10 that we shifted val to get the given mantissa.
      *
      * @return       Offset of next available character in buffer.
      */
     private int combineReal(double val, byte[] buf, int off, int len, byte[] mant, int lmant, int shift) {
 
         // First get the minimum size for the number
 
         double pos = Math.abs(val);
         boolean simple = false;
         int minSize;
         int maxSize;
 
         if (pos >= ByteFormatter.DEFAULT_SIMPLE_MIN && pos <= ByteFormatter.DEFAULT_SIMPLE_MAX) {
             simple = true;
         }
 
         int exp = lmant - shift - 1;
         int lexp = 0;
 
         if (!simple) {
             lexp = format(exp, tbuf2, 0, ByteFormatter.TEMP_BUFFER_SIZE);
 
             minSize = lexp + 2; // e.g., 2e-12
             maxSize = lexp + lmant + 2; // add in "." and e
         } else if (exp >= 0) {
             minSize = exp + 1; // e.g. 32
 
             // Special case. E.g., 99.9 has
             // minumum size of 3.
             int i;
             for (i = 0; i < lmant && i <= exp; i++) {
                 if (mant[i] != (byte) '9') {
                     break;
                 }
             }
             if (i > exp && i < lmant && mant[i] >= (byte) '5') {
                 minSize++;
             }
 
             maxSize = lmant + 1; // Add in "."
             if (maxSize <= minSize) { // Very large numbers.
                 maxSize = minSize + 1;
             }
         } else {
             minSize = 2;
             maxSize = 1 + Math.abs(exp) + lmant;
         }
         if (val < 0) {
             minSize++;
         }
 
         // Can the number fit?
         if (minSize > len || minSize > buf.length - off) {
             truncationFiller(buf, off, len);
             return off + len;
         }
 
         // Now begin filling in the buffer.
         if (val < 0) {
             buf[off] = (byte) '-';
             off++;
             len--;
         }
 
         if (simple) {
             return Math.abs(mantissa(mant, lmant, exp, simple, buf, off, len));
         }
         off = mantissa(mant, lmant, 0, simple, buf, off, len - lexp - 1);
         if (off < 0) {
             off = -off;
             len -= off;
             // Handle the expanded exponent by filling
             if (exp == MAXIMUM_SINGLE_DIGIT_INTEGER || exp == MAXIMUM_TWO_DIGIT_INTEGER) {
                 // Cannot fit...
                 if (off + len == minSize) {
                     truncationFiller(buf, off, len);
                     return off + len;
                 }
                 // Steal a character from the mantissa.
                 off--;
             }
             exp++;
             lexp = format(exp, tbuf2, 0, ByteFormatter.TEMP_BUFFER_SIZE);
         }
         buf[off] = (byte) 'E';
         off++;
         System.arraycopy(tbuf2, 0, buf, off, lexp);
         return off + lexp;
     }
 
     /**
      * Format a boolean into an existing array.
      *
      * @param  val   value to write
      * @param  array the array to fill
      *
      * @return       Offset of next available character in buffer.
      */
     public int format(boolean val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Format a boolean into an existing array
      *
      * @param  val   The boolean to be formatted
      * @param  array The buffer in which to format the data.
      * @param  off   The starting offset within the buffer.
      * @param  len   The maximum number of characters to use use in formatting the number.
      *
      * @return       Offset of next available character in buffer.
      */
     public int format(boolean val, byte[] array, int off, int len) {
         if (len > 0) {
             if (val) {
                 array[off] = (byte) 'T';
             } else {
                 array[off] = (byte) 'F';
             }
             off++;
         }
         return off;
     }
 
     /**
      * Format a double into an array.
      *
      * @param  val   The double to be formatted.
      * @param  array The array in which to place the result.
      *
      * @return       The number of characters used. @ * if the value was truncated
      */
     public int format(double val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Format a double into an existing character array.
      * <p>
      * This is hard to do exactly right... The JDK code does stuff with rational arithmetic and so forth. We use a much
      * simpler algorithm which may give an answer off in the lowest order bit. Since this is pure Java, it should still
      * be consistent from machine to machine.
      * <p>
      * Recall that the binary representation of the double is of the form <code>d = 0.bbbbbbbb x 2<sup>n</sup></code>
      * where there are up to 53 binary digits in the binary fraction (including the assumed leading 1 bit for normalized
      * numbers). We find a value m such that <code>10<sup>m</sup> d</code> is between <code>2<sup>53</sup></code> and
      * <code>2<sup>63</sup></code>. This product will be exactly convertible to a long with no loss of precision.
      * Getting the decimal representation for that is trivial (see formatLong). This is a decimal mantissa and we have
      * an exponent (<code>-m</code>). All we have to do is manipulate the decimal point to where we want to see it.
      * Errors can arise due to roundoff in the scaling multiplication, but should be no more than a single bit.
      *
      * @param  val Double to be formatted
      * @param  buf Buffer in which result is to be stored
      * @param  off Offset within buffer
      * @param  len Maximum length of integer
      *
      * @return     offset of next unused character in input buffer.
      */
     public int format(double val, byte[] buf, int off, int len) {
 
         double pos = Math.abs(val);
 
         // Special cases -- It is OK if these get truncated.
         if (pos == 0.) {
             return format("0.0", buf, off, len);
         }
         if (Double.isNaN(val)) {
             return format(NOT_A_NUMBER, buf, off, len);
         }
         if (Double.isInfinite(val)) {
             if (val > 0) {
                 return format(INFINITY, buf, off, len);
             }
             return format(NEGATIVE_INFINITY, buf, off, len);
         }
 
         int power = (int) (Math.log(pos) * ByteFormatter.I_LOG_10);
         int shift = DOUBLE_SHIFT_BASE - power;
         double scale;
         double scale2 = 1;
 
         // Scale the number so that we get a number ~ n x 10^17.
         if (shift < DOUBLE_SHIFT_LIMIT) {
             scale = ByteFormatter.NUMBER_BASE_POWERS[shift + ByteFormatter.ZERO_POW];
         } else {
             // Can get overflow if the original number is
             // very small, so we break out the shift
             // into two multipliers.
             scale2 = ByteFormatter.NUMBER_BASE_POWERS[DOUBLE_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
             scale = ByteFormatter.NUMBER_BASE_POWERS[shift - DOUBLE_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
         }
 
         pos = pos * scale * scale2;
 
         // Parse the double bits.
 
         long bits = Double.doubleToLongBits(pos);
 
         // The exponent should be a little more than 52.
         int exp = (int) (((bits & DOUBLE_EXPONENT_BIT_MASK) >> DOUBLE_EXPONENT_EXCESS) + DOUBLE_MIN_EXPONENT);
 
         long numb = bits & DOUBLE_VALUE_BIT_MASK;
 
         // this can never be false because the min exponent of a double is -1022
         // but lets keep it if we need it for big decimals
         if (exp > DOUBLE_MIN_EXPONENT) {
             // Normalized....
             numb |= DOUBLE_EXPONENT_NORMALIZE_BIT;
         } else {
             // Denormalized
             exp++;
         }
 
         // Multiple this number by the excess of the exponent
         // over 52. This completes the conversion of double to long.
         numb = numb << exp - DOUBLE_EXPONENT_EXCESS;
 
         // Get a decimal mantissa.
         int ndig = format(numb, tbuf1, 0, ByteFormatter.TEMP_BUFFER_SIZE);
 
         // Now format the double.
 
         return combineReal(val, buf, off, len, tbuf1, ndig, shift);
     }
 
     /**
      * Format a float into an array.
      *
      * @param  val   The float to be formatted.
      * @param  array The array in which to place the result.
      *
      * @return       The number of characters used. @ * if the value was truncated
      */
     public int format(float val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Format a float into an existing byteacter array.
      * <p>
      * This is hard to do exactly right... The JDK code does stuff with rational arithmetic and so forth. We use a much
      * simpler algorithm which may give an answer off in the lowest order bit. Since this is pure Java, it should still
      * be consistent from machine to machine.
      * <p>
      * Recall that the binary representation of the float is of the form <code>d = 0.bbbbbbbb x 2<sup>n</sup></code>
      * where there are up to 24 binary digits in the binary fraction (including the assumed leading 1 bit for normalized
      * numbers). We find a value m such that <code>10<sup>m</sup> d</code> is between <code>2<sup>24</sup></code> and
      * <code>2<sup>32</sup></code>. This product will be exactly convertible to an int with no loss of precision.
      * Getting the decimal representation for that is trivial (see formatInteger). This is a decimal mantissa and we
      * have an exponent ( <code>-m</code>). All we have to do is manipulate the decimal point to where we want to see
      * it. Errors can arise due to roundoff in the scaling multiplication, but should be very small.
      *
      * @param  val Float to be formatted
      * @param  buf Buffer in which result is to be stored
      * @param  off Offset within buffer
      * @param  len Maximum length of field
      *
      * @return     Offset of next character in buffer. @ * if the value was truncated
      */
     public int format(float val, byte[] buf, int off, int len) {
 
         float pos = Math.abs(val);
 
         // Special cases
         if (pos == 0.) {
             return format("0.0", buf, off, len);
         }
         if (Float.isNaN(val)) {
             return format(NOT_A_NUMBER, buf, off, len);
         }
         if (Float.isInfinite(val)) {
             if (val > 0) {
                 return format("Infinity", buf, off, len);
             }
             return format("-Infinity", buf, off, len);
         }
 
         int power = (int) Math.floor(Math.log(pos) * ByteFormatter.I_LOG_10);
         int shift = FLOAT_SHIFT_BASE - power;
         float scale;
         float scale2 = 1;
 
         // Scale the number so that we get a number ~ n x 10^8.
         if (shift < FLOAT_SHIFT_LIMIT) {
             scale = (float) ByteFormatter.NUMBER_BASE_POWERS[shift + ByteFormatter.ZERO_POW];
         } else {
             // Can get overflow if the original number is
             // very small, so we break out the shift
             // into two multipliers.
             scale2 = (float) ByteFormatter.NUMBER_BASE_POWERS[FLOAT_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
             scale = (float) ByteFormatter.NUMBER_BASE_POWERS[shift - FLOAT_SHIFT_LIMIT + ByteFormatter.ZERO_POW];
         }
 
         pos = pos * scale * scale2;
 
         // Parse the float bits.
 
         int bits = Float.floatToIntBits(pos);
 
         // The exponent should be a little more than 23
         int exp = ((bits & FLOAT_EXPONENT_BIT_MASK) >> FLOAT_EXPONENT_EXCESS) + FLOAT_MIN_EXPONENT;
 
         int numb = bits & FLOAT_VALUE_BIT_MASK;
 
         if (exp > FLOAT_MIN_EXPONENT) {
             // Normalized....
             numb |= FLOAT_EXPONENT_NORMALIZE_BIT;
         } else {
             // Denormalized
             exp++;
         }
 
         // Multiple this number by the excess of the exponent
         // over 24. This completes the conversion of float to int
         // (<<= did not work on Alpha TruUnix)
 
         numb = numb << exp - FLOAT_EXPONENT_EXCESS;
 
         // Get a decimal mantissa.
         int ndig = format(numb, tbuf1, 0, ByteFormatter.TEMP_BUFFER_SIZE);
 
         // Now format the float.
 
         return combineReal(val, buf, off, len, tbuf1, ndig, shift);
     }
 
     /**
      * Format an int into an array.
      *
      * @param  val   The int to be formatted.
      * @param  array The array in which to place the result.
      *
      * @return       The number of characters used. @ * if the value was truncated
      */
     public int format(int val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Format an int into an existing array.
      *
      * @param  val Integer to be formatted
      * @param  buf Buffer in which result is to be stored
      * @param  off Offset within buffer
      * @param  len Maximum length of integer
      *
      * @return     offset of next unused character in input buffer.
      */
     public int format(int val, byte[] buf, int off, int len) {
 
         // Special case
         if (val == Integer.MIN_VALUE) {
             if (len > ByteFormatter.NUMBER_BASE) {
                 return format("-2147483648", buf, off, len);
             }
             truncationFiller(buf, off, len);
             return off + len;
         }
 
         int pos = Math.abs(val);
 
         // First count the number of characters in the result.
         // Otherwise we need to use an intermediary buffer.
 
         int ndig = 1;
         int dmax = ByteFormatter.NUMBER_BASE;
 
         while (ndig < ByteFormatter.NUMBER_BASE && pos >= dmax) {
             ndig++;
             dmax *= ByteFormatter.NUMBER_BASE;
         }
 
         if (val < 0) {
             ndig++;
         }
 
         // Truncate if necessary.
         if (ndig > len || ndig > buf.length - off) {
             truncationFiller(buf, off, len);
             return off + len;
         }
 
         // Now insert the actual characters we want -- backwards
         // We use a do{} while() to handle the caByteFormatterse of 0.
 
         off += ndig;
 
         int xoff = off - 1;
         do {
             buf[xoff] = ByteFormatter.DIGITS[pos % ByteFormatter.NUMBER_BASE];
             xoff--;
             pos /= ByteFormatter.NUMBER_BASE;
         } while (pos > 0);
 
         if (val < 0) {
             buf[xoff] = (byte) '-';
         }
 
         return off;
     }
 
     /**
      * Format a long into an array.
      *
      * @param  val   The long to be formatted.
      * @param  array The array in which to place the result.
      *
      * @return       The number of characters used. @ * if the value was truncated
      */
     public int format(long val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Format a long into an existing array.
      *
      * @param  val Long to be formatted
      * @param  buf Buffer in which result is to be stored
      * @param  off Offset within buffer
      * @param  len Maximum length of integer
      *
      * @return     offset of next unused character in input buffer. @ * if the value was truncated
      */
     public int format(long val, byte[] buf, int off, int len) {
         // Special case
         if (val == Long.MIN_VALUE) {
             if (len > MAX_LONG_LENGTH) {
                 return format("-9223372036854775808", buf, off, len);
             }
             truncationFiller(buf, off, len);
             return off + len;
         }
         long pos = Math.abs(val);
         // First count the number of characters in the result.
         // Otherwise we need to use an intermediary buffer.
         int ndig = 1;
         long dmax = ByteFormatter.NUMBER_BASE;
         // Might be faster to try to do this partially in ints
         while (ndig < MAX_LONG_LENGTH && pos >= dmax) {
             ndig++;
             dmax *= ByteFormatter.NUMBER_BASE;
         }
         if (val < 0) {
             ndig++;
         }
         // Truncate if necessary.
         if (ndig > len || ndig > buf.length - off) {
             truncationFiller(buf, off, len);
             return off + len;
         }
         // Now insert the actual characters we want -- backwards.
         off += ndig;
         int xoff = off - 1;
         buf[xoff] = (byte) '0';
         boolean last = pos == 0;
         while (!last) {
             // Work on ints rather than longs.
             int giga = (int) (pos % LONG_TO_INT_MODULO);
             pos /= LONG_TO_INT_MODULO;
             last = pos == 0;
             for (int i = 0; i < MAXIMUM_SINGLE_DIGIT_INTEGER; i++) {
 
                 buf[xoff] = ByteFormatter.DIGITS[giga % ByteFormatter.NUMBER_BASE];
                 xoff--;
                 giga /= ByteFormatter.NUMBER_BASE;
                 if (last && giga == 0) {
                     break;
                 }
             }
         }
 
         if (val < 0) {
             buf[xoff] = (byte) '-';
         }
 
         return off;
     }
 
     /**
      * Insert a string at the beginning of an array. * @return Offset of next available character in buffer.
      *
      * @param  val   The string to be inserted. A null string will insert len spaces.
      * @param  array The buffer in which to insert the string.
      *
      * @return       Offset of next available character in buffer.
      */
     public int format(String val, byte[] array) {
         return format(val, array, 0, array.length);
     }
 
     /**
      * Insert a String into an existing character array. If the String is longer than len, then only the the initial len
      * characters will be inserted.
      *
      * @param  val   The string to be inserted. A null string will insert len spaces.
      * @param  array The buffer in which to insert the string.
      * @param  off   The starting offset to insert the string.
      * @param  len   The maximum number of characters to insert.
      *
      * @return       Offset of next available character in buffer.
      */
     public int format(String val, byte[] array, int off, int len) {
 
         if (val == null) {
             for (int i = 0; i < len; i++) {
                 array[off + i] = (byte) ' ';
             }
             return off + len;
         }
 
         int slen = val.length();
 
         if (slen > len || slen > array.length - off) {
             val = val.substring(0, len);
             slen = len;
         }
 
         System.arraycopy(AsciiFuncs.getBytes(val), 0, array, off, slen);
         return off + slen;
     }
 
     /**
      * Write the mantissa of the number. This method addresses the subtleties involved in rounding numbers.
      */
     private int mantissa(byte[] mant, int lmant, int exp, boolean simple, byte[] buf, int off, int len) {
 
         // Save in case we need to extend the number.
         int off0 = off;
         int pos = 0;
 
         if (exp < 0) {
             buf[off] = (byte) '0';
             len--;
             off++;
             if (len > 0) {
                 buf[off] = (byte) '.';
                 off++;
                 len--;
             }
             // Leading 0s in small numbers.
             int cexp = exp;
             while (cexp < -1 && len > 0) {
                 buf[off] = (byte) '0';
                 cexp++;
                 off++;
                 len--;
             }
 
         } else {
 
             // Print out all digits to the left of the decimal.
             while (exp >= 0 && pos < lmant) {
                 buf[off] = mant[pos];
                 off++;
                 pos++;
                 len--;
                 exp--;
             }
             // Trust we have enough space for this.
             for (int i = 0; i <= exp; i++) {
                 buf[off] = (byte) '0';
                 off++;
                 len--;
             }
 
             // Add in a decimal if we have space.
             if (len > 0) {
                 buf[off] = (byte) '.';
                 len--;
                 off++;
             }
         }
 
         // Now handle the digits to the right of the decimal.
         while (len > 0 && pos < lmant) {
             buf[off] = mant[pos];
             off++;
             exp--;
             len--;
             pos++;
         }
 
         // Now handle rounding.
 
         if (pos < lmant && mant[pos] >= (byte) '5') {
             int i;
 
             // Increment to the left until we find a non-9
             for (i = off - 1; i >= off0; i--) {
 
                 if (buf[i] == (byte) '.' || buf[i] == (byte) '-') {
                     continue;
                 }
                 if (buf[i] != (byte) '9') {
                     buf[i]++;
                     break;
                 }
                 buf[i] = (byte) '0';
             }
 
             // Now we handle 99.99 case. This can cause problems
             // in two cases. If we are not using scientific notation
             // then we may want to convert 99.9 to 100., i.e.,
             // we need to move the decimal point. If there is no
             // decimal point, then we must not be truncating on overflow
             // but we should be allowed to write it to the
             // next character (i.e., we are not at the end of buf).
             //
             // If we are printing in scientific notation, then we want
             // to convert 9.99 to 1.00, i.e. we do not move the decimal.
             // However we need to signal that the exponent should be
             // incremented by one.
             //
             // We cannot have aligned the number, since that requires
             // the full precision number to fit within the requested
             // length, and we would have printed out the entire
             // mantissa (i.e., pos >= lmant)
 
             if (i < off0) {
 
                 buf[off0] = (byte) '1';
                 boolean foundDecimal = false;
                 for (i = off0 + 1; i < off; i++) {
                     if (buf[i] == (byte) '.') {
                         foundDecimal = true;
                         if (simple) {
                             buf[i] = (byte) '0';
                             i++;
                             if (i < off) {
                                 buf[i] = (byte) '.';
                             }
                         }
                         break;
                     }
                 }
                 if (simple && !foundDecimal) {
                     buf[off + 1] = (byte) '0'; // 99 went to 100
                     off++;
                 }
 
                 off = -off; // Signal to change exponent if necessary.
             }
 
         }
 
         return off;
     }
 
     /**
      * Fill the buffer with truncation characters. After filling the buffer, a TruncationException will be thrown if the
      * appropriate flag is set.
      */
     private void truncationFiller(byte[] buffer, int offset, int length) {
         for (int i = offset; i < offset + length; i++) {
             buffer[i] = ByteFormatter.TRUNCATION_FILL;
         }
     }
 
 }