/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You 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 org.apache.poi.ss.format;
import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.util.BitSet;
import java.util.Collections;
import java.util.Formatter;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import org.apache.poi.ss.format.CellFormatPart.PartHandler;
/**
* This class implements printing out a value using a number format.
*
* @author Ken Arnold, Industrious Media LLC
*/
public class CellNumberFormatter extends CellFormatter {
private final String desc;
private String printfFmt;
private double scale;
private Special decimalPoint;
private Special slash;
private Special exponent;
private Special numerator;
private Special afterInteger;
private Special afterFractional;
private boolean integerCommas;
private final List<Special> specials;
private List<Special> integerSpecials;
private List<Special> fractionalSpecials;
private List<Special> numeratorSpecials;
private List<Special> denominatorSpecials;
private List<Special> exponentSpecials;
private List<Special> exponentDigitSpecials;
private int maxDenominator;
private String numeratorFmt;
private String denominatorFmt;
private boolean improperFraction;
private DecimalFormat decimalFmt;
static final CellFormatter SIMPLE_NUMBER = new CellFormatter("General") {
public void formatValue(StringBuffer toAppendTo, Object value) {
if (value == null)
return;
if (value instanceof Number) {
Number num = (Number) value;
if (num.doubleValue() % 1.0 == 0)
SIMPLE_INT.formatValue(toAppendTo, value);
else
SIMPLE_FLOAT.formatValue(toAppendTo, value);
} else {
CellTextFormatter.SIMPLE_TEXT.formatValue(toAppendTo, value);
}
}
public void simpleValue(StringBuffer toAppendTo, Object value) {
formatValue(toAppendTo, value);
}
};
private static final CellFormatter SIMPLE_INT = new CellNumberFormatter(
"#");
private static final CellFormatter SIMPLE_FLOAT = new CellNumberFormatter(
"#.#");
/**
* This class is used to mark where the special characters in the format
* are, as opposed to the other characters that are simply printed.
*/
static class Special {
final char ch;
int pos;
Special(char ch, int pos) {
this.ch = ch;
this.pos = pos;
}
@Override
public String toString() {
return "'" + ch + "' @ " + pos;
}
}
/**
* This class represents a single modification to a result string. The way
* this works is complicated, but so is numeric formatting. In general, for
* most formats, we use a DecimalFormat object that will put the string out
* in a known format, usually with all possible leading and trailing zeros.
* We then walk through the result and the orginal format, and note any
* modifications that need to be made. Finally, we go through and apply
* them all, dealing with overlapping modifications.
*/
static class StringMod implements Comparable<StringMod> {
final Special special;
final int op;
CharSequence toAdd;
Special end;
boolean startInclusive;
boolean endInclusive;
public static final int BEFORE = 1;
public static final int AFTER = 2;
public static final int REPLACE = 3;
private StringMod(Special special, CharSequence toAdd, int op) {
this.special = special;
this.toAdd = toAdd;
this.op = op;
}
public StringMod(Special start, boolean startInclusive, Special end,
boolean endInclusive, char toAdd) {
this(start, startInclusive, end, endInclusive);
this.toAdd = toAdd + "";
}
public StringMod(Special start, boolean startInclusive, Special end,
boolean endInclusive) {
special = start;
this.startInclusive = startInclusive;
this.end = end;
this.endInclusive = endInclusive;
op = REPLACE;
toAdd = "";
}
public int compareTo(StringMod that) {
int diff = special.pos - that.special.pos;
if (diff != 0)
return diff;
else
return op - that.op;
}
@Override
public boolean equals(Object that) {
try {
return compareTo((StringMod) that) == 0;
} catch (RuntimeException ignored) {
// NullPointerException or CastException
return false;
}
}
@Override
public int hashCode() {
return special.hashCode() + op;
}
}
private class NumPartHandler implements PartHandler {
private char insertSignForExponent;
public String handlePart(Matcher m, String part, CellFormatType type,
StringBuffer desc) {
int pos = desc.length();
char firstCh = part.charAt(0);
switch (firstCh) {
case 'e':
case 'E':
// See comment in writeScientific -- exponent handling is complex.
// (1) When parsing the format, remove the sign from after the 'e' and
// put it before the first digit of the exponent.
if (exponent == null && specials.size() > 0) {
specials.add(exponent = new Special('.', pos));
insertSignForExponent = part.charAt(1);
return part.substring(0, 1);
}
break;
case '0':
case '?':
case '#':
if (insertSignForExponent != '\0') {
specials.add(new Special(insertSignForExponent, pos));
desc.append(insertSignForExponent);
insertSignForExponent = '\0';
pos++;
}
for (int i = 0; i < part.length(); i++) {
char ch = part.charAt(i);
specials.add(new Special(ch, pos + i));
}
break;
case '.':
if (decimalPoint == null && specials.size() > 0)
specials.add(decimalPoint = new Special('.', pos));
break;
case '/':
//!! This assumes there is a numerator and a denominator, but these are actually optional
if (slash == null && specials.size() > 0) {
numerator = previousNumber();
// If the first number in the whole format is the numerator, the
// entire number should be printed as an improper fraction
if (numerator == firstDigit(specials))
improperFraction = true;
specials.add(slash = new Special('.', pos));
}
break;
case '%':
// don't need to remember because we don't need to do anything with these
scale *= 100;
break;
default:
return null;
}
return part;
}
}
/**
* Creates a new cell number formatter.
*
* @param format The format to parse.
*/
public CellNumberFormatter(String format) {
super(format);
scale = 1;
specials = new LinkedList<>();
NumPartHandler partHandler = new NumPartHandler();
StringBuffer descBuf = CellFormatPart.parseFormat(format,
CellFormatType.NUMBER, partHandler);
// These are inconsistent settings, so ditch 'em
if ((decimalPoint != null || exponent != null) && slash != null) {
slash = null;
numerator = null;
}
interpretCommas(descBuf);
int precision;
int fractionPartWidth = 0;
if (decimalPoint == null) {
precision = 0;
} else {
precision = interpretPrecision();
fractionPartWidth = 1 + precision;
if (precision == 0) {
// This means the format has a ".", but that output should have no decimals after it.
// We just stop treating it specially
specials.remove(decimalPoint);
decimalPoint = null;
}
}
if (precision == 0)
fractionalSpecials = Collections.emptyList();
else
fractionalSpecials = specials.subList(specials.indexOf(
decimalPoint) + 1, fractionalEnd());
if (exponent == null)
exponentSpecials = Collections.emptyList();
else {
int exponentPos = specials.indexOf(exponent);
exponentSpecials = specialsFor(exponentPos, 2);
exponentDigitSpecials = specialsFor(exponentPos + 2);
}
if (slash == null) {
numeratorSpecials = Collections.emptyList();
denominatorSpecials = Collections.emptyList();
} else {
if (numerator == null)
numeratorSpecials = Collections.emptyList();
else
numeratorSpecials = specialsFor(specials.indexOf(numerator));
denominatorSpecials = specialsFor(specials.indexOf(slash) + 1);
if (denominatorSpecials.isEmpty()) {
// no denominator follows the slash, drop the fraction idea
numeratorSpecials = Collections.emptyList();
} else {
maxDenominator = maxValue(denominatorSpecials);
numeratorFmt = singleNumberFormat(numeratorSpecials);
denominatorFmt = singleNumberFormat(denominatorSpecials);
}
}
integerSpecials = specials.subList(0, integerEnd());
if (exponent == null) {
StringBuffer fmtBuf = new StringBuffer("%");
int integerPartWidth = calculateIntegerPartWidth();
int totalWidth = integerPartWidth + fractionPartWidth;
fmtBuf.append('0').append(totalWidth).append('.').append(precision);
fmtBuf.append("f");
printfFmt = fmtBuf.toString();
} else {
StringBuffer fmtBuf = new StringBuffer();
boolean first = true;
List<Special> specialList = integerSpecials;
if (integerSpecials.size() == 1) {
// If we don't do this, we get ".6e5" instead of "6e4"
fmtBuf.append("0");
first = false;
} else
for (Special s : specialList) {
if (isDigitFmt(s)) {
fmtBuf.append(first ? '#' : '0');
first = false;
}
}
if (fractionalSpecials.size() > 0) {
fmtBuf.append('.');
for (Special s : fractionalSpecials) {
if (isDigitFmt(s)) {
if (!first)
fmtBuf.append('0');
first = false;
}
}
}
fmtBuf.append('E');
placeZeros(fmtBuf, exponentSpecials.subList(2,
exponentSpecials.size()));
decimalFmt = new DecimalFormat(fmtBuf.toString());
}
if (exponent != null)
scale =
1; // in "e" formats,% and trailing commas have no scaling effect
desc = descBuf.toString();
}
private static void placeZeros(StringBuffer sb, List<Special> specials) {
for (Special s : specials) {
if (isDigitFmt(s))
sb.append('0');
}
}
private static Special firstDigit(List<Special> specials) {
for (Special s : specials) {
if (isDigitFmt(s))
return s;
}
return null;
}
static StringMod insertMod(Special special, CharSequence toAdd, int where) {
return new StringMod(special, toAdd, where);
}
static StringMod deleteMod(Special start, boolean startInclusive,
Special end, boolean endInclusive) {
return new StringMod(start, startInclusive, end, endInclusive);
}
static StringMod replaceMod(Special start, boolean startInclusive,
Special end, boolean endInclusive, char withChar) {
return new StringMod(start, startInclusive, end, endInclusive,
withChar);
}
private static String singleNumberFormat(List<Special> numSpecials) {
return "%0" + numSpecials.size() + "d";
}
private static int maxValue(List<Special> s) {
return (int) Math.round(Math.pow(10, s.size()) - 1);
}
private List<Special> specialsFor(int pos, int takeFirst) {
if (pos >= specials.size())
return Collections.emptyList();
ListIterator<Special> it = specials.listIterator(pos + takeFirst);
Special last = it.next();
int end = pos + takeFirst;
while (it.hasNext()) {
Special s = it.next();
if (!isDigitFmt(s) || s.pos - last.pos > 1)
break;
end++;
last = s;
}
return specials.subList(pos, end + 1);
}
private List<Special> specialsFor(int pos) {
return specialsFor(pos, 0);
}
private static boolean isDigitFmt(Special s) {
return s.ch == '0' || s.ch == '?' || s.ch == '#';
}
private Special previousNumber() {
ListIterator<Special> it = specials.listIterator(specials.size());
while (it.hasPrevious()) {
Special s = it.previous();
if (isDigitFmt(s)) {
Special numStart = s;
Special last = s;
while (it.hasPrevious()) {
s = it.previous();
if (last.pos - s.pos > 1) // it has to be continuous digits
break;
if (isDigitFmt(s))
numStart = s;
else
break;
last = s;
}
return numStart;
}
}
return null;
}
private int calculateIntegerPartWidth() {
ListIterator<Special> it = specials.listIterator();
int digitCount = 0;
while (it.hasNext()) {
Special s = it.next();
//!! Handle fractions: The previous set of digits before that is the numerator, so we should stop short of that
if (s == afterInteger)
break;
else if (isDigitFmt(s))
digitCount++;
}
return digitCount;
}
private int interpretPrecision() {
if (decimalPoint == null) {
return -1;
} else {
int precision = 0;
ListIterator<Special> it = specials.listIterator(specials.indexOf(
decimalPoint));
if (it.hasNext())
it.next(); // skip over the decimal point itself
while (it.hasNext()) {
Special s = it.next();
if (isDigitFmt(s))
precision++;
else
break;
}
return precision;
}
}
private void interpretCommas(StringBuffer sb) {
// In the integer part, commas at the end are scaling commas; other commas mean to show thousand-grouping commas
ListIterator<Special> it = specials.listIterator(integerEnd());
boolean stillScaling = true;
integerCommas = false;
while (it.hasPrevious()) {
Special s = it.previous();
if (s.ch != ',') {
stillScaling = false;
} else {
if (stillScaling) {
scale /= 1000;
} else {
integerCommas = true;
}
}
}
if (decimalPoint != null) {
it = specials.listIterator(fractionalEnd());
while (it.hasPrevious()) {
Special s = it.previous();
if (s.ch != ',') {
break;
} else {
scale /= 1000;
}
}
}
// Now strip them out -- we only need their interpretation, not their presence
it = specials.listIterator();
int removed = 0;
while (it.hasNext()) {
Special s = it.next();
s.pos -= removed;
if (s.ch == ',') {
removed++;
it.remove();
sb.deleteCharAt(s.pos);
}
}
}
private int integerEnd() {
if (decimalPoint != null)
afterInteger = decimalPoint;
else if (exponent != null)
afterInteger = exponent;
else if (numerator != null)
afterInteger = numerator;
else
afterInteger = null;
return afterInteger == null ? specials.size() : specials.indexOf(
afterInteger);
}
private int fractionalEnd() {
int end;
if (exponent != null)
afterFractional = exponent;
else if (numerator != null)
afterInteger = numerator;
else
afterFractional = null;
end = afterFractional == null ? specials.size() : specials.indexOf(
afterFractional);
return end;
}
/** {@inheritDoc} */
public void formatValue(StringBuffer toAppendTo, Object valueObject) {
double value = ((Number) valueObject).doubleValue();
value *= scale;
// the '-' sign goes at the front, always, so we pick it out
boolean negative = value < 0;
if (negative)
value = -value;
// Split out the fractional part if we need to print a fraction
double fractional = 0;
if (slash != null) {
if (improperFraction) {
fractional = value;
value = 0;
} else {
fractional = value % 1.0;
//noinspection SillyAssignment
value = (long) value;
}
}
Set<StringMod> mods = new TreeSet<>();
StringBuffer output = new StringBuffer(desc);
if (exponent != null) {
writeScientific(value, output, mods);
} else if (improperFraction) {
writeFraction(value, null, fractional, output, mods);
} else {
StringBuffer result = new StringBuffer();
Formatter f = new Formatter(result);
f.format(LOCALE, printfFmt, value);
if (numerator == null) {
writeFractional(result, output);
writeInteger(result, output, integerSpecials, mods,
integerCommas);
} else {
writeFraction(value, result, fractional, output, mods);
}
}
// Now strip out any remaining '#'s and add any pending text ...
ListIterator<Special> it = specials.listIterator();
Iterator<StringMod> changes = mods.iterator();
StringMod nextChange = (changes.hasNext() ? changes.next() : null);
int adjust = 0;
BitSet deletedChars = new BitSet(); // records chars already deleted
while (it.hasNext()) {
Special s = it.next();
int adjustedPos = s.pos + adjust;
if (!deletedChars.get(s.pos) && output.charAt(adjustedPos) == '#') {
output.deleteCharAt(adjustedPos);
adjust--;
deletedChars.set(s.pos);
}
while (nextChange != null && s == nextChange.special) {
int lenBefore = output.length();
int modPos = s.pos + adjust;
int posTweak = 0;
switch (nextChange.op) {
case StringMod.AFTER:
// ignore adding a comma after a deleted char (which was a '#')
if (nextChange.toAdd.equals(",") && deletedChars.get(s.pos))
break;
posTweak = 1;
//noinspection fallthrough
case StringMod.BEFORE:
output.insert(modPos + posTweak, nextChange.toAdd);
break;
case StringMod.REPLACE:
int delPos =
s.pos; // delete starting pos in original coordinates
if (!nextChange.startInclusive) {
delPos++;
modPos++;
}
// Skip over anything already deleted
while (deletedChars.get(delPos)) {
delPos++;
modPos++;
}
int delEndPos =
nextChange.end.pos; // delete end point in original
if (nextChange.endInclusive)
delEndPos++;
int modEndPos =
delEndPos + adjust; // delete end point in current
if (modPos < modEndPos) {
if (nextChange.toAdd == "")
output.delete(modPos, modEndPos);
else {
char fillCh = nextChange.toAdd.charAt(0);
for (int i = modPos; i < modEndPos; i++)
output.setCharAt(i, fillCh);
}
deletedChars.set(delPos, delEndPos);
}
break;
default:
throw new IllegalStateException(
"Unknown op: " + nextChange.op);
}
adjust += output.length() - lenBefore;
if (changes.hasNext())
nextChange = changes.next();
else
nextChange = null;
}
}
// Finally, add it to the string
if (negative)
toAppendTo.append('-');
toAppendTo.append(output);
}
private void writeScientific(double value, StringBuffer output,
Set<StringMod> mods) {
StringBuffer result = new StringBuffer();
FieldPosition fractionPos = new FieldPosition(
DecimalFormat.FRACTION_FIELD);
decimalFmt.format(value, result, fractionPos);
writeInteger(result, output, integerSpecials, mods, integerCommas);
writeFractional(result, output);
/*
* Exponent sign handling is complex.
*
* In DecimalFormat, you never put the sign in the format, and the sign only
* comes out of the format if it is negative.
*
* In Excel, you always say whether to always show the sign ("e+") or only
* show negative signs ("e-").
*
* Also in Excel, where you put the sign in the format is NOT where it comes
* out in the result. In the format, the sign goes with the "e"; in the
* output it goes with the exponent value. That is, if you say "#e-|#" you
* get "1e|-5", not "1e-|5". This makes sense I suppose, but it complicates
* things.
*
* Finally, everything else in this formatting code assumes that the base of
* the result is the original format, and that starting from that situation,
* the indexes of the original special characters can be used to place the new
* characters. As just described, this is not true for the exponent's sign.
* <p/>
* So here is how we handle it:
*
* (1) When parsing the format, remove the sign from after the 'e' and put it
* before the first digit of the exponent (where it will be shown).
*
* (2) Determine the result's sign.
*
* (3) If it's missing, put the sign into the output to keep the result
* lined up with the output. (In the result, "after the 'e'" and "before the
* first digit" are the same because the result has no extra chars to be in
* the way.)
*
* (4) In the output, remove the sign if it should not be shown ("e-" was used
* and the sign is negative) or set it to the correct value.
*/
// (2) Determine the result's sign.
int ePos = fractionPos.getEndIndex();
int signPos = ePos + 1;
char expSignRes = result.charAt(signPos);
if (expSignRes != '-') {
// not a sign, so it's a digit, and therefore a positive exponent
expSignRes = '+';
// (3) If it's missing, put the sign into the output to keep the result
// lined up with the output.
result.insert(signPos, '+');
}
// Now the result lines up like it is supposed to with the specials' indexes
ListIterator<Special> it = exponentSpecials.listIterator(1);
Special expSign = it.next();
char expSignFmt = expSign.ch;
// (4) In the output, remove the sign if it should not be shown or set it to
// the correct value.
if (expSignRes == '-' || expSignFmt == '+')
mods.add(replaceMod(expSign, true, expSign, true, expSignRes));
else
mods.add(deleteMod(expSign, true, expSign, true));
StringBuffer exponentNum = new StringBuffer(result.substring(
signPos + 1));
writeInteger(exponentNum, output, exponentDigitSpecials, mods, false);
}
private void writeFraction(double value, StringBuffer result,
double fractional, StringBuffer output, Set<StringMod> mods) {
// Figure out if we are to suppress either the integer or fractional part.
// With # the suppressed part is removed; with ? it is replaced with spaces.
if (!improperFraction) {
// If fractional part is zero, and numerator doesn't have '0', write out
// only the integer part and strip the rest.
if (fractional == 0 && !hasChar('0', numeratorSpecials)) {
writeInteger(result, output, integerSpecials, mods, false);
Special start = integerSpecials.get(integerSpecials.size() - 1);
Special end = denominatorSpecials.get(
denominatorSpecials.size() - 1);
if (hasChar('?', integerSpecials, numeratorSpecials,
denominatorSpecials)) {
//if any format has '?', then replace the fraction with spaces
mods.add(replaceMod(start, false, end, true, ' '));
} else {
// otherwise, remove the fraction
mods.add(deleteMod(start, false, end, true));
}
// That's all, just return
return;
} else {
// New we check to see if we should remove the integer part
boolean allZero = (value == 0 && fractional == 0);
boolean willShowFraction = fractional != 0 || hasChar('0',
numeratorSpecials);
boolean removeBecauseZero = allZero && (hasOnly('#',
integerSpecials) || !hasChar('0', numeratorSpecials));
boolean removeBecauseFraction =
!allZero && value == 0 && willShowFraction && !hasChar(
'0', integerSpecials);
if (removeBecauseZero || removeBecauseFraction) {
Special start = integerSpecials.get(
integerSpecials.size() - 1);
if (hasChar('?', integerSpecials, numeratorSpecials)) {
mods.add(replaceMod(start, true, numerator, false,
' '));
} else {
mods.add(deleteMod(start, true, numerator, false));
}
} else {
// Not removing the integer part -- print it out
writeInteger(result, output, integerSpecials, mods, false);
}
}
}
// Calculate and print the actual fraction (improper or otherwise)
try {
int n;
int d;
// the "fractional % 1" captures integer values in improper fractions
if (fractional == 0 || (improperFraction && fractional % 1 == 0)) {
// 0 as a fraction is reported by excel as 0/1
n = (int) Math.round(fractional);
d = 1;
} else {
Fraction frac = new Fraction(fractional, maxDenominator);
n = frac.getNumerator();
d = frac.getDenominator();
}
if (improperFraction)
n += Math.round(value * d);
writeSingleInteger(numeratorFmt, n, output, numeratorSpecials,
mods);
writeSingleInteger(denominatorFmt, d, output, denominatorSpecials,
mods);
} catch (RuntimeException ignored) {
ignored.printStackTrace();
}
}
private static boolean hasChar(char ch, List<Special>... numSpecials) {
for (List<Special> specials : numSpecials) {
for (Special s : specials) {
if (s.ch == ch) {
return true;
}
}
}
return false;
}
private static boolean hasOnly(char ch, List<Special>... numSpecials) {
for (List<Special> specials : numSpecials) {
for (Special s : specials) {
if (s.ch != ch) {
return false;
}
}
}
return true;
}
private void writeSingleInteger(String fmt, int num, StringBuffer output,
List<Special> numSpecials, Set<StringMod> mods) {
StringBuffer sb = new StringBuffer();
Formatter formatter = new Formatter(sb);
formatter.format(LOCALE, fmt, num);
writeInteger(sb, output, numSpecials, mods, false);
}
private void writeInteger(StringBuffer result, StringBuffer output,
List<Special> numSpecials, Set<StringMod> mods,
boolean showCommas) {
int pos = result.indexOf(".") - 1;
if (pos < 0) {
if (exponent != null && numSpecials == integerSpecials)
pos = result.indexOf("E") - 1;
else
pos = result.length() - 1;
}
int strip;
for (strip = 0; strip < pos; strip++) {
char resultCh = result.charAt(strip);
if (resultCh != '0' && resultCh != ',')
break;
}
ListIterator<Special> it = numSpecials.listIterator(numSpecials.size());
boolean followWithComma = false;
Special lastOutputIntegerDigit = null;
int digit = 0;
while (it.hasPrevious()) {
char resultCh;
if (pos >= 0)
resultCh = result.charAt(pos);
else {
// If result is shorter than field, pretend there are leading zeros
resultCh = '0';
}
Special s = it.previous();
followWithComma = showCommas && digit > 0 && digit % 3 == 0;
boolean zeroStrip = false;
if (resultCh != '0' || s.ch == '0' || s.ch == '?' || pos >= strip) {
zeroStrip = s.ch == '?' && pos < strip;
output.setCharAt(s.pos, (zeroStrip ? ' ' : resultCh));
lastOutputIntegerDigit = s;
}
if (followWithComma) {
mods.add(insertMod(s, zeroStrip ? " " : ",", StringMod.AFTER));
followWithComma = false;
}
digit++;
--pos;
}
StringBuffer extraLeadingDigits = new StringBuffer();
if (pos >= 0) {
// We ran out of places to put digits before we ran out of digits; put this aside so we can add it later
++pos; // pos was decremented at the end of the loop above when the iterator was at its end
extraLeadingDigits = new StringBuffer(result.substring(0, pos));
if (showCommas) {
while (pos > 0) {
if (digit > 0 && digit % 3 == 0)
extraLeadingDigits.insert(pos, ',');
digit++;
--pos;
}
}
mods.add(insertMod(lastOutputIntegerDigit, extraLeadingDigits,
StringMod.BEFORE));
}
}
private void writeFractional(StringBuffer result, StringBuffer output) {
int digit;
int strip;
ListIterator<Special> it;
if (fractionalSpecials.size() > 0) {
digit = result.indexOf(".") + 1;
if (exponent != null)
strip = result.indexOf("e") - 1;
else
strip = result.length() - 1;
while (strip > digit && result.charAt(strip) == '0')
strip--;
it = fractionalSpecials.listIterator();
while (it.hasNext()) {
Special s = it.next();
char resultCh = result.charAt(digit);
if (resultCh != '0' || s.ch == '0' || digit < strip)
output.setCharAt(s.pos, resultCh);
else if (s.ch == '?') {
// This is when we're in trailing zeros, and the format is '?'. We still strip out remaining '#'s later
output.setCharAt(s.pos, ' ');
}
digit++;
}
}
}
/**
* {@inheritDoc}
* <p/>
* For a number, this is <tt>"#"</tt> for integer values, and <tt>"#.#"</tt>
* for floating-point values.
*/
public void simpleValue(StringBuffer toAppendTo, Object value) {
SIMPLE_NUMBER.formatValue(toAppendTo, value);
}
/**
* Based on org.apache.commons.math.fraction.Fraction from Apache Commons-Math.
* YK: The only reason of having this inner class is to avoid dependency on the Commons-Math jar.
*/
private static class Fraction {
/** The denominator. */
private final int denominator;
/** The numerator. */
private final int numerator;
/**
* Create a fraction given the double value and either the maximum error
* allowed or the maximum number of denominator digits.
*
* @param value the double value to convert to a fraction.
* @param epsilon maximum error allowed. The resulting fraction is within
* <code>epsilon</code> of <code>value</code>, in absolute terms.
* @param maxDenominator maximum denominator value allowed.
* @param maxIterations maximum number of convergents
* @throws RuntimeException if the continued fraction failed to
* converge.
*/
private Fraction(double value, double epsilon, int maxDenominator, int maxIterations)
{
long overflow = Integer.MAX_VALUE;
double r0 = value;
long a0 = (long)Math.floor(r0);
if (a0 > overflow) {
throw new IllegalArgumentException("Overflow trying to convert "+value+" to fraction ("+a0+"/"+1l+")");
}
// check for (almost) integer arguments, which should not go
// to iterations.
if (Math.abs(a0 - value) < epsilon) {
this.numerator = (int) a0;
this.denominator = 1;
return;
}
long p0 = 1;
long q0 = 0;
long p1 = a0;
long q1 = 1;
long p2;
long q2;
int n = 0;
boolean stop = false;
do {
++n;
double r1 = 1.0 / (r0 - a0);
long a1 = (long)Math.floor(r1);
p2 = (a1 * p1) + p0;
q2 = (a1 * q1) + q0;
if ((p2 > overflow) || (q2 > overflow)) {
throw new RuntimeException("Overflow trying to convert "+value+" to fraction ("+p2+"/"+q2+")");
}
double convergent = (double)p2 / (double)q2;
if (n < maxIterations && Math.abs(convergent - value) > epsilon && q2 < maxDenominator) {
p0 = p1;
p1 = p2;
q0 = q1;
q1 = q2;
a0 = a1;
r0 = r1;
} else {
stop = true;
}
} while (!stop);
if (n >= maxIterations) {
throw new RuntimeException("Unable to convert "+value+" to fraction after "+maxIterations+" iterations");
}
if (q2 < maxDenominator) {
this.numerator = (int) p2;
this.denominator = (int) q2;
} else {
this.numerator = (int) p1;
this.denominator = (int) q1;
}
}
/**
* Create a fraction given the double value and maximum denominator.
* <p>
* References:
* <ul>
* <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
* Continued Fraction</a> equations (11) and (22)-(26)</li>
* </ul>
* </p>
* @param value the double value to convert to a fraction.
* @param maxDenominator The maximum allowed value for denominator
* @throws RuntimeException if the continued fraction failed to
* converge
*/
public Fraction(double value, int maxDenominator)
{
this(value, 0, maxDenominator, 100);
}
/**
* Access the denominator.
* @return the denominator.
*/
public int getDenominator() {
return denominator;
}
/**
* Access the numerator.
* @return the numerator.
*/
public int getNumerator() {
return numerator;
}
}
}