/** The rounding mode dominant in the formatter. */

static final RoundingMode ROUND_PY = RoundingMode.HALF_EVEN;

/** Limit the size of results. */

// No-one needs more than log(Double.MAX_VALUE) - log2(Double.MIN_VALUE) = 1383 digits.

static final int MAX_PRECISION = 1400;

/** If it contains no decimal point, this length is zero, and 1 otherwise. */

private int lenPoint;

/** The length of the fractional part, right of the decimal point. */

private int lenFraction;

/** The length of the exponent marker ("e"), "inf" or "nan", or zero if there isn't one. */

private int lenMarker;

/** The length of the exponent sign and digits or zero if there isn't one. */

private int lenExponent;

/** if ≥0, minimum digits to follow decimal point (where consulted) */

private int minFracDigits;

/**

public FloatFormatter(StringBuilder result, Spec spec) {

super(result, spec);

if (spec.alternate) {

// Alternate form means do not trim the zero fractional digits.

minFracDigits = -1;

} else if (spec.type == 'r' || spec.type == Spec.NONE) {

// These formats by default show at least one fractional digit.

minFracDigits = 1;

} else {

/*

minFracDigits = 0;

}

}

/**

public FloatFormatter(Spec spec) {

this(new StringBuilder(size(spec)), spec);

}

/**

public static int size(Spec spec) {

// Rule of thumb used here (no right answer):

// in e format each float occupies: (p-1) + len("+1.e+300") = p+7;

// in f format each float occupies: p + len("1,000,000.%") = p+11;

// or an explicit (minimum) width may be given, with one overshoot possible.

return Math.max(spec.width + 1, spec.getPrecision(6) + 11);

}

/**

public void setMinFracDigits(int minFracDigits) {

this.minFracDigits = minFracDigits;

}

@Override

protected void reset() {

// Clear the variables describing the latest number in result.

super.reset();

lenPoint = lenFraction = lenMarker = lenExponent = 0;

}

@Override

protected int[] sectionLengths() {

return new int[] {lenSign, lenWhole, lenPoint, lenFraction, lenMarker, lenExponent};

}

/*

@Override

public FloatFormatter append(char c) {

super.append(c);

return this;

}

@Override

public FloatFormatter append(CharSequence csq) {

super.append(csq);

return this;

}

@Override

public FloatFormatter append(CharSequence csq, int start, int end) //

throws IndexOutOfBoundsException {

super.append(csq, start, end);

return this;

}

/**

public FloatFormatter format(double value) {

return format(value, null);

}

/**

@SuppressWarnings("fallthrough")

public FloatFormatter format(double value, String positivePrefix) {

// Puts all instance variables back to their starting defaults, and start = result.length().

setStart();

// Precision defaults to 6 (or 12 for none-format)

int precision = spec.getPrecision(Spec.specified(spec.type) ? 6 : 12);

// Guard against excessive result precision

// XXX Possibly better raised before result is allocated/sized.

if (precision > MAX_PRECISION) {

throw precisionTooLarge("float");

}

/*

char sign = spec.sign;

if (positivePrefix == null && Spec.specified(sign) && sign != '-') {

positivePrefix = Character.toString(sign);

}

// Different process for each format type, ignoring case for now.

switch (Character.toLowerCase(spec.type)) {

case 'e':

// Exponential case: 1.23e-45

format_e(value, positivePrefix, precision);

break;

case 'f':

// Fixed case: 123.45

format_f(value, positivePrefix, precision);

break;

case 'n':

// Locale-sensitive version of g-format should be here. (Désolé de vous decevoir.)

// XXX Set a variable here to signal localisation in/after groupDigits?

case 'g':

// General format: fixed or exponential according to value.

format_g(value, positivePrefix, precision, 0);

break;

case Spec.NONE:

// None format like g-format but goes exponential at precision-1

format_g(value, positivePrefix, precision, -1);

break;

case 'r':

// For float.__repr__, very special case, breaks all the rules.

format_r(value, positivePrefix);

break;

case '%':

// Multiplies by 100 and displays in f-format, followed by a percent sign.

format_f(100. * value, positivePrefix, precision);

result.append('%');

break;

default:

// Should never get here, since this was checked in PyFloat.

throw unknownFormat(spec.type, "float");

}

// If the format type is an upper-case letter, convert the result to upper case.

if (Character.isUpperCase(spec.type)) {

uppercase();

}

// If required to, group the whole-part digits.

if (spec.grouping) {

groupDigits(3, ',');

}

return this;

}

/**

@Override

protected void uppercase() {

int letters = indexOfMarker();

int end = letters + lenMarker;

for (int i = letters; i < end; i++) {

char c = result.charAt(i);

result.setCharAt(i, Character.toUpperCase(c));

}

}

/**

private boolean signAndSpecialNumber(double value, String positivePrefix) {

// This is easiest via the raw bits

long bits = Double.doubleToRawLongBits(value);

// NaN is always positive

if (Double.isNaN(value)) {

bits &= ~SIGN_MASK;

}

if ((bits & SIGN_MASK) != 0) {

// Negative: encode a minus sign and strip it off bits

result.append('-');

lenSign = 1;

bits &= ~SIGN_MASK;

} else if (positivePrefix != null) {

// Positive, and a prefix is required. Note CPython 2.7 produces "+nan", " nan".

result.append(positivePrefix);

lenSign = positivePrefix.length();

}

if (bits == 0L) {

// All zero means it's zero. (It may have been negative, producing -0.)

result.append('0');

lenWhole = 1;

return true;

} else if ((bits & EXP_MASK) == EXP_MASK) {

// This is characteristic of NaN or Infinity.

result.append(((bits & ~EXP_MASK) == 0L) ? "inf" : "nan");

lenMarker = 3;

return true;

} else {

return false;

}

}

private static final long SIGN_MASK = 0x8000000000000000L;

private static final long EXP_MASK = 0x7ff0000000000000L;

/**

private void format_e(double value, String positivePrefix, int precision) {

// Exponent (default value is for 0.0 and -0.0)

int exp = 0;

if (!signAndSpecialNumber(value, positivePrefix)) {

// Convert abs(value) to decimal with p+1 digits of accuracy.

MathContext mc = new MathContext(precision + 1, ROUND_PY);

BigDecimal vv = new BigDecimal(Math.abs(value), mc);

// Take explicit control in order to get exponential notation out of BigDecimal.

String digits = vv.unscaledValue().toString();

int digitCount = digits.length();

result.append(digits.charAt(0));

lenWhole = 1;

if (digitCount > 1) {

// There is a fractional part

result.append('.').append(digits.substring(1));

lenPoint = 1;

lenFraction = digitCount - 1;

}

exp = lenFraction - vv.scale();

}

// If the result is not already complete, add point and zeros as necessary, and exponent.

if (lenMarker == 0) {

ensurePointAndTrailingZeros(precision);

appendExponent(exp);

}

}

/**

private void format_f(double value, String positivePrefix, int precision) {

if (!signAndSpecialNumber(value, positivePrefix)) {

// Convert value to decimal exactly. (This can be very long.)

BigDecimal vLong = new BigDecimal(Math.abs(value));

// Truncate to the defined number of places to the right of the decimal point).

BigDecimal vv = vLong.setScale(precision, ROUND_PY);

// When converted to text, the number of fractional digits is exactly the scale we set.

String raw = vv.toPlainString();

result.append(raw);

if ((lenFraction = vv.scale()) > 0) {

// There is a decimal point and some digits following

lenWhole = result.length() - (start + lenSign + (lenPoint = 1) + lenFraction);

} else {

// There are no fractional digits and so no decimal point

lenWhole = result.length() - (start + lenSign);

}

}

// Finally, ensure we have all the fractional digits we should.

if (lenMarker == 0) {

ensurePointAndTrailingZeros(precision);

}

}

/**

private void ensurePointAndTrailingZeros(int n) {

// Set n to the number of fractional digits we should have.

if (n < minFracDigits) {

n = minFracDigits;

}

// Do we have a decimal point already?

if (lenPoint == 0) {

// No decimal point: add one if there will be any fractional digits or

if (n > 0 || minFracDigits < 0) {

// First need to add a decimal point.

result.append('.');

lenPoint = 1;

}

}

// Do we have enough fractional digits already?

int f = lenFraction;

if (n > f) {

// Make up the required number of zeros.

for (; f < n; f++) {

result.append('0');

}

lenFraction = f;

}

}

/**

private void format_g(double value, String positivePrefix, int precision, int expThresholdAdj) {

// Precision 0 behaves as 1

precision = Math.max(1, precision);

// Use exponential notation if exponent would be bigger thatn:

int expThreshold = precision + expThresholdAdj;

if (signAndSpecialNumber(value, positivePrefix)) {

// Finish formatting if zero result. (This is a no-op for nan or inf.)

zeroHelper(precision, expThreshold);

} else {

// Convert abs(value) to decimal with p digits of accuracy.

MathContext mc = new MathContext(precision, ROUND_PY);

BigDecimal vv = new BigDecimal(Math.abs(value), mc);

// This gives us the digits we need for either fixed or exponential format.

String pointlessDigits = vv.unscaledValue().toString();

// If we were to complete this as e-format, the exponent would be:

int exp = pointlessDigits.length() - vv.scale() - 1;

if (-4 <= exp && exp < expThreshold) {

// Finish the job as f-format with variable-precision p-(exp+1).

appendFixed(pointlessDigits, exp, precision);

} else {

// Finish the job as e-format.

appendExponential(pointlessDigits, exp);

}

}

}

/**

private void format_r(double value, String positivePrefix) {

// Characteristics of repr (precision = 17 and go exponential at 16).

int precision = 17;

int expThreshold = precision - 1;

if (signAndSpecialNumber(value, positivePrefix)) {

// Finish formatting if zero result. (This is a no-op for nan or inf.)

zeroHelper(precision, expThreshold);

} else {

// Generate digit sequence (with no decimal point) with custom rounding.

StringBuilder pointlessBuffer = new StringBuilder(20);

int exp = reprDigits(Math.abs(value), precision, pointlessBuffer);

if (-4 <= exp && exp < expThreshold) {

// Finish the job as f-format with variable-precision p-(exp+1).

appendFixed(pointlessBuffer, exp, precision);

} else {

// Finish the job as e-format.

appendExponential(pointlessBuffer, exp);

}

}

}

/**

private void zeroHelper(int precision, int expThreshold) {

if (lenMarker == 0) {

// May be 0 or -0 so we still need to ...

if (minFracDigits < 0) {

// In "alternate format", we won't economise trailing zeros.

appendPointAndTrailingZeros(precision - 1);

} else if (lenFraction < minFracDigits) {

// Otherwise, it should be at least the stated minimum length.

appendTrailingZeros(minFracDigits);

}

// And just occasionally (in none-format) we go exponential even when exp = 0...

if (0 >= expThreshold) {

appendExponent(0);

}

}

}

/**

private void appendFixed(CharSequence digits, int exp, int precision) {

// Check for "alternate format", where we won't economise trailing zeros.

boolean noTruncate = (minFracDigits < 0);

int digitCount = digits.length();

if (exp < 0) {

// For a negative exponent, we must insert leading zeros 0.000 ...

result.append("0.");

lenWhole = lenPoint = 1;

for (int i = -1; i > exp; --i) {

result.append('0');

}

// Then the generated digits (always enough to satisfy no-truncate mode).

result.append(digits);

lenFraction = digitCount - exp - 1;

} else {

// For a non-negative exponent, it's a question of placing the decimal point.

int w = exp + 1;

if (w < digitCount) {

// There are w whole-part digits

result.append(digits.subSequence(0, w));

lenWhole = w;

result.append('.').append(digits.subSequence(w, digitCount));

lenPoint = 1;

lenFraction = digitCount - w;

} else {

// All the digits are whole-part digits.

result.append(digits);

// Just occasionally (in r-format) we need more digits than the precision.

while (digitCount < w) {

result.append('0');

digitCount += 1;

}

lenWhole = digitCount;

}

if (noTruncate) {

// Extend the fraction as BigDecimal will have economised on zeros.

appendPointAndTrailingZeros(precision - digitCount);

}

}

// Finally, ensure we have all and only the fractional digits we should.

if (!noTruncate) {

if (lenFraction < minFracDigits) {

// Otherwise, it should be at least the stated minimum length.

appendTrailingZeros(minFracDigits);

} else {

// And no more

removeTrailingZeros(minFracDigits);

}

}

}

/**

private void appendExponential(CharSequence digits, int exp) {

// The whole-part is the first digit.

result.append(digits.charAt(0));

lenWhole = 1;

// And the rest of the digits form the fractional part

int digitCount = digits.length();

result.append('.').append(digits.subSequence(1, digitCount));

lenPoint = 1;

lenFraction = digitCount - 1;

// In no-truncate mode, the fraction is full precision. Otherwise trim it.

if (minFracDigits >= 0) {

// Note positive minFracDigits only applies to fixed formats.

removeTrailingZeros(0);

}

// Finally, append the exponent as e+nn.

appendExponent(exp);

}

/**

private static int reprDigits(double value, int maxDigits, StringBuilder buf) {

// Most of the work is done by Double.

String s = Double.toString(value);

// Variables for scanning the string

int p = 0, end = s.length(), first = 0, point = end, exp;

char c = 0;

boolean allZero = true;

// Scan whole part and fractional part digits

while (p < end) {

c = s.charAt(p++);

if (Character.isDigit(c)) {

if (allZero) {

if (c != '0') {

// This is the first non-zero digit.

buf.append(c);

allZero = false;

// p is one *after* the first non-zero digit.

first = p;

}

// Only seen zeros so far: do nothing.

} else {

// We've started, so every digit counts.

buf.append(c);

}

} else if (c == '.') {

// We remember this location (one *after* '.') to calculate the exponent later.

point = p;

} else {

// Something after the mantissa. (c=='E' we hope.)

break;

}

}

// Possibly followed by an exponent. p has already advanced past the 'E'.

if (p < end && c == 'E') {

// If there is an exponent, the mantissa must be in standard form: m.mmmm

assert point == first + 1;

exp = Integer.parseInt(s.substring(p));

} else {

// Exponent is based on relationship of decimal point and first non-zero digit.

exp = point - first - 1;

// But that's only correct when the point is to the right (or absent).

if (exp < 0) {

// The point is to the left of the first digit

exp += 1; // = -(first-point)

}

}

/*

// Sometimes the result is more digits than we want for repr.

if (buf.length() > maxDigits) {

// Chop the trailing digits, remembering the most significant lost digit.

int d = buf.charAt(maxDigits);

buf.setLength(maxDigits);

// We round half up. Not absolutely correct since Double has already rounded.

if (d >= '5') {

// Treat this as a "carry one" into the numeral buf[0:maxDigits].

for (p = maxDigits - 1; p >= 0; p--) {

// Each pass of the loop does one carry from buf[p+1] to buf[p].

d = buf.charAt(p) + 1;

if (d <= '9') {

// Carry propagation stops here.

buf.setCharAt(p, (char)d);

break;

} else {

// 9 + 1 -> 0 carry 1. Keep looping.

buf.setCharAt(p, '0');

}

}

if (p < 0) {

/*

buf.setCharAt(0, '1');

exp += 1;

}

}

}

return exp;

}

/**

private void appendTrailingZeros(int n) {

int f = lenFraction;

if (n > f) {

if (lenPoint == 0) {

// First need to add a decimal point. (Implies lenFraction=0.)

result.append('.');

lenPoint = 1;

}

// Now make up the required number of zeros.

for (; f < n; f++) {

result.append('0');

}

lenFraction = f;

}

}

/**

private void appendPointAndTrailingZeros(int n) {

if (lenPoint == 0) {

// First need to add a decimal point. (Implies lenFraction=0.)

result.append('.');

lenPoint = 1;

}

// Now make up the required number of zeros.

int f;

for (f = lenFraction; f < n; f++) {

result.append('0');

}

lenFraction = f;

}

/**

private void removeTrailingZeros(int n) {

if (lenPoint > 0) {

// There's a decimal point at least, and there may be some fractional digits.

int f = lenFraction;

if (n == 0 || f > n) {

int fracStart = result.length() - f;

for (; f > n; --f) {

if (result.charAt(fracStart - 1 + f) != '0') {

// Keeping this one as it isn't a zero

break;

}

}

// f is now the number of fractional digits we wish to retain.

if (f == 0) {

// We will be stripping all the fractional digits. Take the decimal point too.

lenPoint = lenFraction = 0;

f = -1;

} else {

lenFraction = f;

}

// Snip the characters we are going to remove (if any).

if (fracStart + f < result.length()) {

result.setLength(fracStart + f);

}

}

}

}

/**

private void appendExponent(int exp) {

int marker = result.length();

String e;

// Deal with sign and leading-zero convention by explicit tests.

if (exp < 0) {

e = (exp <= -10) ? "e-" : "e-0";

exp = -exp;

} else {

e = (exp < 10) ? "e+0" : "e+";

}

result.append(e).append(exp);

lenMarker = 1;

lenExponent = result.length() - marker - 1;

}

/**

private int indexOfMarker() {

return start + lenSign + lenWhole + lenPoint + lenFraction;

}