/* ====================================================================
|
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.
|
==================================================================== */
|
namespace HH.WMS.Utils.NPOI.SS.Format
|
{
|
using System;
|
using System.Text.RegularExpressions;
|
using System.Text;
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using HH.WMS.Utils.NPOI.SS.Util;
|
using System.Collections;
|
|
|
/**
|
* This class : printing out a value using a number format.
|
*
|
* @author Ken Arnold, Industrious Media LLC
|
*/
|
public class CellNumberFormatter : CellFormatter
|
{
|
private String desc;
|
private String printfFmt;
|
private double scale;
|
private Special decimalPoint;
|
private Special slash;
|
private Special exponent;
|
private Special numerator;
|
private Special Afterint;
|
private Special AfterFractional;
|
private bool integerCommas;
|
private 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 bool improperFraction;
|
private DecimalFormat decimalFmt;
|
private static List<Special> EmptySpecialList = new List<Special>();
|
private class SimpleNumberCellFormatter : CellFormatter
|
{
|
public SimpleNumberCellFormatter(string format)
|
: base(format)
|
{
|
|
}
|
public override void FormatValue(StringBuilder toAppendTo, Object value)
|
{
|
if (value == null)
|
return;
|
if (value.GetType().IsPrimitive/* is Number*/)
|
{
|
double num = (double)value;
|
if (num % 1.0 == 0)
|
SIMPLE_INT.FormatValue(toAppendTo, value);
|
else
|
SIMPLE_FLOAT.FormatValue(toAppendTo, value);
|
}
|
else
|
{
|
CellTextFormatter.SIMPLE_TEXT.FormatValue(toAppendTo, value);
|
}
|
}
|
public override void SimpleValue(StringBuilder toAppendTo, Object value)
|
{
|
FormatValue(toAppendTo, value);
|
}
|
}
|
static CellFormatter SIMPLE_NUMBER = new SimpleNumberCellFormatter("General");
|
|
private static CellFormatter SIMPLE_INT = new CellNumberFormatter("#");
|
private static 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.
|
*/
|
internal class Special
|
{
|
internal char ch;
|
internal int pos;
|
|
public Special(char ch, int pos)
|
{
|
this.ch = ch;
|
this.pos = pos;
|
}
|
|
|
public override 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.
|
*/
|
internal class StringMod : IComparable<StringMod>
|
{
|
internal Special special;
|
internal int op;
|
internal string toAdd;
|
internal Special end;
|
internal bool startInclusive;
|
internal bool endInclusive;
|
|
public const int BEFORE = 1;
|
public const int AFTER = 2;
|
public const int REPLACE = 3;
|
|
public StringMod(Special special, string toAdd, int op)
|
{
|
this.special = special;
|
this.toAdd = toAdd;
|
this.op = op;
|
}
|
|
public StringMod(Special start, bool startInclusive, Special end,
|
bool endInclusive, char toAdd)
|
: this(start, startInclusive, end, endInclusive)
|
{
|
this.toAdd = toAdd + "";
|
}
|
|
public StringMod(Special start, bool startInclusive, Special end,
|
bool 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;
|
}
|
|
|
public override bool Equals(Object that)
|
{
|
try
|
{
|
return CompareTo((StringMod)that) == 0;
|
}
|
catch (Exception)
|
{
|
// NullPointerException or CastException
|
return false;
|
}
|
}
|
|
|
public override int GetHashCode()
|
{
|
return special.GetHashCode() + op;
|
}
|
}
|
|
private class NumPartHandler : CellFormatPart.IPartHandler
|
{
|
private char insertSignForExponent;
|
CellNumberFormatter formatter;
|
public NumPartHandler(CellNumberFormatter formatter)
|
{
|
this.formatter = formatter;
|
}
|
public String HandlePart(Match m, String part, CellFormatType type,
|
StringBuilder desc)
|
{
|
int pos = desc.Length;
|
char firstCh = part[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 (formatter.exponent == null && formatter.specials.Count > 0)
|
{
|
formatter.specials.Add(formatter.exponent = new Special('.', pos));
|
insertSignForExponent = part[1];
|
return part.Substring(0, 1);
|
}
|
break;
|
|
case '0':
|
case '?':
|
case '#':
|
if (insertSignForExponent != '\0')
|
{
|
formatter.specials.Add(new Special(insertSignForExponent, pos));
|
desc.Append(insertSignForExponent);
|
insertSignForExponent = '\0';
|
pos++;
|
}
|
for (int i = 0; i < part.Length; i++)
|
{
|
char ch = part[i];
|
formatter.specials.Add(new Special(ch, pos + i));
|
}
|
break;
|
|
case '.':
|
if (formatter.decimalPoint == null && formatter.specials.Count > 0)
|
formatter.specials.Add(formatter.decimalPoint = new Special('.', pos));
|
break;
|
|
case '/':
|
//!! This assumes there is a numerator and a denominator, but these are actually optional
|
if (formatter.slash == null && formatter.specials.Count > 0)
|
{
|
formatter.numerator = formatter.previousNumber();
|
// If the first number in the whole format is the numerator, the
|
// entire number should be printed as an improper fraction
|
if (formatter.numerator == firstDigit(formatter.specials))
|
formatter.improperFraction = true;
|
formatter.specials.Add(formatter.slash = new Special('.', pos));
|
}
|
break;
|
|
case '%':
|
// don't need to remember because we don't need to do anything with these
|
formatter.scale *= 100;
|
break;
|
|
default:
|
return null;
|
}
|
return part;
|
}
|
}
|
/**
|
* Creates a new cell number formatter.
|
*
|
* @param format The format to Parse.
|
*/
|
public CellNumberFormatter(String format)
|
: base(format)
|
{
|
;
|
|
scale = 1;
|
|
specials = new List<Special>();
|
|
NumPartHandler partHandler = new NumPartHandler(this);
|
StringBuilder descBuf = CellFormatPart.ParseFormat(format,
|
CellFormatType.NUMBER, partHandler);
|
string fmt = descBuf.ToString();
|
// 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 = EmptySpecialList;
|
else
|
{
|
int pos = specials.IndexOf(decimalPoint) + 1;
|
fractionalSpecials = specials.GetRange(pos, fractionalEnd() - pos);
|
}
|
if (exponent == null)
|
exponentSpecials = EmptySpecialList;
|
else
|
{
|
int exponentPos = specials.IndexOf(exponent);
|
exponentSpecials = specialsFor(exponentPos, 2);
|
exponentDigitSpecials = specialsFor(exponentPos + 2);
|
}
|
|
if (slash == null)
|
{
|
numeratorSpecials = EmptySpecialList;
|
denominatorSpecials = EmptySpecialList;
|
}
|
else
|
{
|
if (numerator == null)
|
numeratorSpecials = EmptySpecialList;
|
else
|
numeratorSpecials = specialsFor(specials.IndexOf(numerator));
|
|
denominatorSpecials = specialsFor(specials.IndexOf(slash) + 1);
|
if (denominatorSpecials.Count == 0)
|
{
|
// no denominator follows the slash, drop the fraction idea
|
numeratorSpecials = EmptySpecialList;
|
}
|
else
|
{
|
maxDenominator = maxValue(denominatorSpecials);
|
numeratorFmt = SingleNumberFormat(numeratorSpecials);
|
denominatorFmt = SingleNumberFormat(denominatorSpecials);
|
}
|
}
|
|
integerSpecials = specials.GetRange(0, integerEnd());
|
|
if (exponent == null)
|
{
|
StringBuilder fmtBuf = new StringBuilder();
|
|
int integerPartWidth = calculateintPartWidth();
|
//int totalWidth = integerPartWidth + fractionPartWidth;
|
|
fmtBuf.Append('0', integerPartWidth).Append('.').Append('0', precision);
|
|
//fmtBuf.Append("f");
|
printfFmt = fmtBuf.ToString();
|
|
//this number format is legal in C#;
|
//printfFmt = fmt;
|
}
|
else
|
{
|
StringBuilder fmtBuf = new StringBuilder();
|
bool first = true;
|
List<Special> specialList = integerSpecials;
|
if (integerSpecials.Count == 1)
|
{
|
// If we don't do this, we Get ".6e5" instead of "6e4"
|
fmtBuf.Append("0");
|
first = false;
|
}
|
else
|
foreach (Special s in specialList)
|
{
|
if (IsDigitFmt(s))
|
{
|
fmtBuf.Append(first ? '#' : '0');
|
first = false;
|
}
|
}
|
if (fractionalSpecials.Count > 0)
|
{
|
fmtBuf.Append('.');
|
foreach (Special s in fractionalSpecials)
|
{
|
if (IsDigitFmt(s))
|
{
|
if (!first)
|
fmtBuf.Append('0');
|
first = false;
|
}
|
}
|
}
|
fmtBuf.Append('E');
|
placeZeros(fmtBuf, exponentSpecials.GetRange(2,
|
exponentSpecials.Count - 2));
|
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(StringBuilder sb, List<Special> specials)
|
{
|
foreach (Special s in specials)
|
{
|
if (IsDigitFmt(s))
|
sb.Append('0');
|
}
|
}
|
|
private static Special firstDigit(List<Special> specials)
|
{
|
foreach (Special s in specials)
|
{
|
if (IsDigitFmt(s))
|
return s;
|
}
|
return null;
|
}
|
|
static StringMod insertMod(Special special, string toAdd, int where)
|
{
|
return new StringMod(special, toAdd, where);
|
}
|
|
static StringMod deleteMod(Special start, bool startInclusive,
|
Special end, bool endInclusive)
|
{
|
|
return new StringMod(start, startInclusive, end, endInclusive);
|
}
|
|
static StringMod ReplaceMod(Special start, bool startInclusive,
|
Special end, bool endInclusive, char withChar)
|
{
|
|
return new StringMod(start, startInclusive, end, endInclusive,
|
withChar);
|
}
|
|
private static String SingleNumberFormat(List<Special> numSpecials)
|
{
|
//return "%0" + numSpecials.Count + "d";
|
return "D" + numSpecials.Count;
|
}
|
|
private static int maxValue(List<Special> s)
|
{
|
return (int)Math.Round(Math.Pow(10, s.Count) - 1);
|
}
|
|
private List<Special> specialsFor(int pos, int takeFirst)
|
{
|
if (pos >= specials.Count)
|
return EmptySpecialList;
|
IEnumerator<Special> it = specials.GetRange(pos + takeFirst, specials.Count - pos - takeFirst).GetEnumerator();
|
//.ListIterator(pos + takeFirst);
|
it.MoveNext();
|
Special last = it.Current;
|
int end = pos + takeFirst;
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
if (!IsDigitFmt(s) || s.pos - last.pos > 1)
|
break;
|
end++;
|
last = s;
|
}
|
return specials.GetRange(pos, end + 1 - pos);
|
}
|
|
private List<Special> specialsFor(int pos)
|
{
|
return specialsFor(pos, 0);
|
}
|
|
private static bool IsDigitFmt(Special s)
|
{
|
return s.ch == '0' || s.ch == '?' || s.ch == '#';
|
}
|
|
private Special previousNumber()
|
{
|
//ListIterator<Special> it = specials.ListIterator(specials.Count);
|
//while (it.HasPrevious())
|
for (int i = specials.Count - 1; i >= 0; i--)
|
{
|
Special s = specials[i];
|
if (IsDigitFmt(s))
|
{
|
Special numStart = s;
|
Special last = s;
|
while (i > 0)
|
{
|
i--;
|
s = specials[i];
|
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 calculateintPartWidth()
|
{
|
IEnumerator<Special> it = specials.GetEnumerator();
|
int digitCount = 0;
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
//!! Handle fractions: The previous Set of digits before that is the numerator, so we should stop short of that
|
if (s == Afterint)
|
break;
|
else if (IsDigitFmt(s))
|
digitCount++;
|
}
|
return digitCount;
|
}
|
|
private int interpretPrecision()
|
{
|
if (decimalPoint == null)
|
{
|
return -1;
|
}
|
else
|
{
|
int precision = 0;
|
int pos = specials.IndexOf(decimalPoint);
|
IEnumerator<Special> it = specials.GetRange(pos, specials.Count - pos).GetEnumerator();//.ListIterator(specials.IndexOf(decimalPoint));
|
//if (it.HasNext())
|
// it.Next(); // skip over the decimal point itself
|
it.MoveNext();
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
if (IsDigitFmt(s))
|
precision++;
|
else
|
break;
|
}
|
return precision;
|
}
|
}
|
|
private void interpretCommas(StringBuilder sb)
|
{
|
// In the integer part, commas at the end are scaling commas; other commas mean to show thousand-grouping commas
|
int pos = integerEnd();
|
List<Special> list = specials.GetRange(0, pos);//.ListIterator();
|
|
bool stillScaling = true;
|
integerCommas = false;
|
//while (it.HasPrevious())
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
Special s = list[i];
|
if (s.ch != ',')
|
{
|
stillScaling = false;
|
}
|
else
|
{
|
if (stillScaling)
|
{
|
scale /= 1000;
|
}
|
else
|
{
|
integerCommas = true;
|
}
|
}
|
}
|
|
if (decimalPoint != null)
|
{
|
pos = fractionalEnd();
|
list = specials.GetRange(0, pos);//.ListIterator(fractionalEnd());
|
//while (it.HasPrevious())
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
Special s = list[i];
|
if (s.ch != ',')
|
{
|
break;
|
}
|
else
|
{
|
scale /= 1000;
|
}
|
}
|
}
|
|
// Now strip them out -- we only need their interpretation, not their presence
|
IEnumerator<Special> it = specials.GetEnumerator();
|
int Removed = 0;
|
List<Special> toRemove = new List<Special>();
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
s.pos -= Removed;
|
if (s.ch == ',')
|
{
|
Removed++;
|
//it.Remove();
|
toRemove.Add(s);
|
sb.Remove(s.pos, 1);
|
}
|
}
|
foreach (Special e in toRemove)
|
{
|
specials.Remove(e);
|
}
|
}
|
|
private int integerEnd()
|
{
|
if (decimalPoint != null)
|
Afterint = decimalPoint;
|
else if (exponent != null)
|
Afterint = exponent;
|
else if (numerator != null)
|
Afterint = numerator;
|
else
|
Afterint = null;
|
return Afterint == null ? specials.Count : specials.IndexOf(
|
Afterint);
|
}
|
|
private int fractionalEnd()
|
{
|
int end;
|
if (exponent != null)
|
AfterFractional = exponent;
|
else if (numerator != null)
|
Afterint = numerator;
|
else
|
AfterFractional = null;
|
end = AfterFractional == null ? specials.Count : specials.IndexOf(
|
AfterFractional);
|
return end;
|
}
|
|
/** {@inheritDoc} */
|
public override void FormatValue(StringBuilder toAppendTo, Object valueObject)
|
{
|
double value = ((double)valueObject);
|
value *= scale;
|
|
// the '-' sign goes at the front, always, so we pick it out
|
bool 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;
|
}
|
}
|
|
SortedList<StringMod, object> mods = new SortedList<StringMod, object>();
|
StringBuilder output = new StringBuilder(desc);
|
|
if (exponent != null)
|
{
|
WriteScientific(value, output, mods);
|
}
|
else if (improperFraction)
|
{
|
WriteFraction(value, null, fractional, output, mods);
|
}
|
else
|
{
|
StringBuilder result = new StringBuilder();
|
//Formatter f = new Formatter(result);
|
//f.Format(LOCALE, printfFmt, value);
|
result.Append(value.ToString(printfFmt));
|
if (numerator == null)
|
{
|
WriteFractional(result, output);
|
Writeint(result, output, integerSpecials, mods,
|
integerCommas);
|
}
|
else
|
{
|
WriteFraction(value, result, fractional, output, mods);
|
}
|
}
|
|
// Now strip out any remaining '#'s and add any pending text ...
|
IEnumerator<Special> it = specials.GetEnumerator();//.ListIterator();
|
IEnumerator Changes = mods.Keys.GetEnumerator();
|
StringMod nextChange = (Changes.MoveNext() ? (StringMod)Changes.Current : null);
|
int adjust = 0;
|
BitArray deletedChars = new BitArray(1024); // records chars already deleted
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
int adjustedPos = s.pos + adjust;
|
if (!deletedChars[(s.pos)] && output[adjustedPos] == '#')
|
{
|
output.Remove(adjustedPos, 1);
|
adjust--;
|
deletedChars.Set(s.pos, true);
|
}
|
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;
|
output.Insert(modPos + posTweak, nextChange.toAdd);
|
break;
|
//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.Remove(modPos, modEndPos - modPos);
|
else
|
{
|
char FillCh = nextChange.toAdd[0];
|
for (int i = modPos; i < modEndPos; i++)
|
output[i] = FillCh;
|
}
|
for (int k = delPos; k < delEndPos; k++)
|
deletedChars.Set(k, true);
|
//deletedChars.Set(delPos, delEndPos);
|
}
|
break;
|
|
default:
|
throw new InvalidOperationException(
|
"Unknown op: " + nextChange.op);
|
}
|
adjust += output.Length - lenBefore;
|
|
if (Changes.MoveNext())
|
nextChange = (StringMod)Changes.Current;
|
else
|
nextChange = null;
|
}
|
}
|
|
// Finally, add it to the string
|
if (negative)
|
toAppendTo.Append('-');
|
//toAppendTo.Append(value.ToString(format));
|
toAppendTo.Append(output);
|
}
|
|
private void WriteScientific(double value, StringBuilder output,
|
SortedList<StringMod, object> mods)
|
{
|
|
StringBuilder result = new StringBuilder();
|
//FieldPosition fractionPos = new FieldPosition(DecimalFormat.FRACTION_FIELD;
|
//decimalFmt.Format(value, result, fractionPos);
|
|
//
|
string pattern = decimalFmt.Pattern;
|
int pos = 0;
|
while (true)
|
{
|
if (pattern[pos] == '#' || pattern[pos] == '0')
|
{
|
pos++;
|
}
|
else
|
break;
|
}
|
int integerNum = pos;
|
if (pattern[0] == '#')
|
integerNum--;
|
if (integerNum >= 6&& value>1)
|
{
|
pattern = pattern.Substring(1);
|
result.Append(value.ToString(pattern));
|
}
|
else
|
{
|
result.Append(value.ToString("E"));
|
}
|
|
Writeint(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.
|
string tmp = result.ToString();
|
int ePos =tmp.IndexOf("E");// fractionPos.EndIndex;
|
int signPos = ePos + 1;
|
char expSignRes = result[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.
|
if (tmp.IndexOf(expSignRes, ePos) < 0)
|
result.Insert(signPos, '+');
|
}
|
|
// Now the result lines up like it is supposed to with the specials' indexes
|
IEnumerator<Special> it = exponentSpecials.GetEnumerator();//.ListIterator(1);
|
it.MoveNext();
|
it.MoveNext();
|
Special expSign = it.Current;//.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), null);
|
else
|
mods.Add(deleteMod(expSign, true, expSign, true), null);
|
|
StringBuilder exponentNum = new StringBuilder(result.ToString().Substring(
|
signPos + 1));
|
if (exponentNum.Length > 2 && exponentNum[0] == '0')
|
exponentNum.Remove(0, 1);
|
Writeint(exponentNum, output, exponentDigitSpecials, mods, false);
|
}
|
|
private void WriteFraction(double value, StringBuilder result,
|
double fractional, StringBuilder output, SortedList<StringMod, object> 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))
|
{
|
Writeint(result, output, integerSpecials, mods, false);
|
|
Special start = integerSpecials[(integerSpecials.Count - 1)];
|
Special end = denominatorSpecials[(
|
denominatorSpecials.Count - 1)];
|
if (HasChar('?', integerSpecials, numeratorSpecials,
|
denominatorSpecials))
|
{
|
//if any format has '?', then replace the fraction with spaces
|
mods.Add(ReplaceMod(start, false, end, true, ' '), null);
|
}
|
else
|
{
|
// otherwise, remove the fraction
|
mods.Add(deleteMod(start, false, end, true), null);
|
}
|
|
// That's all, just return
|
return;
|
}
|
else
|
{
|
// New we check to see if we should remove the integer part
|
bool allZero = (value == 0 && fractional == 0);
|
bool willShowFraction = fractional != 0 || HasChar('0',
|
numeratorSpecials);
|
bool RemoveBecauseZero = allZero && (HasOnly('#',
|
integerSpecials) || !HasChar('0', numeratorSpecials));
|
bool RemoveBecauseFraction =
|
!allZero && value == 0 && willShowFraction && !HasChar(
|
'0', integerSpecials);
|
if (RemoveBecauseZero || RemoveBecauseFraction)
|
{
|
Special start = integerSpecials[(
|
integerSpecials.Count - 1)];
|
if (HasChar('?', integerSpecials, numeratorSpecials))
|
{
|
mods.Add(ReplaceMod(start, true, numerator, false,
|
' '), null);
|
}
|
else
|
{
|
mods.Add(deleteMod(start, true, numerator, false), null);
|
}
|
}
|
else
|
{
|
// Not removing the integer part -- print it out
|
Writeint(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.Numerator;
|
d = frac.Denominator;
|
}
|
if (improperFraction)
|
n += (int)Math.Round(value * d);
|
WriteSingleint(numeratorFmt, n, output, numeratorSpecials,
|
mods);
|
WriteSingleint(denominatorFmt, d, output, denominatorSpecials,
|
mods);
|
}
|
catch (Exception ignored)
|
{
|
//ignored.PrintStackTrace();
|
System.Console.WriteLine(ignored.StackTrace);
|
}
|
}
|
//private static bool HasChar(char ch, List<Special> s1, List<Special> s2, List<Special> s3)
|
//{
|
// return HasChar(ch, s1) || HasChar(ch, s2) || HasChar(ch, s3);
|
//}
|
//private static bool HasChar(char ch, List<Special> s1, List<Special> s2)
|
//{
|
// return HasChar(ch, s1) || HasChar(ch, s2);
|
//}
|
private static bool HasChar(char ch, params List<Special>[] numSpecials)
|
{
|
foreach (List<Special> specials in numSpecials)
|
{
|
foreach (Special s in specials)
|
{
|
if (s.ch == ch)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
private static bool HasOnly(char ch, params List<Special>[] numSpecials)
|
{
|
foreach (List<Special> specials in numSpecials)
|
{
|
foreach (Special s in specials)
|
{
|
if (s.ch != ch)
|
{
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
|
private void WriteSingleint(String fmt, int num, StringBuilder output,
|
List<Special> numSpecials, SortedList<StringMod, object> mods)
|
{
|
|
StringBuilder sb = new StringBuilder();
|
//Formatter formatter = new Formatter(sb);
|
//formatter.Format(LOCALE, fmt, num);
|
sb.Append(num.ToString(fmt));
|
Writeint(sb, output, numSpecials, mods, false);
|
}
|
|
private void Writeint(StringBuilder result, StringBuilder output,
|
List<Special> numSpecials, SortedList<StringMod, object> mods,
|
bool ShowCommas)
|
{
|
|
int pos = result.ToString().IndexOf(".") - 1;
|
if (pos < 0)
|
{
|
if (exponent != null && numSpecials == integerSpecials)
|
pos = result.ToString().IndexOf("E") - 1;
|
else
|
pos = result.Length - 1;
|
}
|
|
int strip;
|
for (strip = 0; strip < pos; strip++)
|
{
|
char resultCh = result[strip];
|
if (resultCh != '0' && resultCh != ',')
|
break;
|
}
|
|
//ListIterator<Special> it = numSpecials.ListIterator(numSpecials.Count);
|
bool followWithComma = false;
|
Special lastOutputintDigit = null;
|
int digit = 0;
|
//while (it.HasPrevious()) {
|
for (int i = numSpecials.Count - 1; i >= 0; i--)
|
{
|
char resultCh;
|
if (pos >= 0)
|
resultCh = result[pos];
|
else
|
{
|
// If result is shorter than field, pretend there are leading zeros
|
resultCh = '0';
|
}
|
Special s = numSpecials[i];
|
followWithComma = ShowCommas && digit > 0 && digit % 3 == 0;
|
bool zeroStrip = false;
|
if (resultCh != '0' || s.ch == '0' || s.ch == '?' || pos >= strip)
|
{
|
zeroStrip = (s.ch == '?' && pos < strip);
|
output[s.pos] = (zeroStrip ? ' ' : resultCh);
|
lastOutputintDigit = s;
|
}
|
if (followWithComma)
|
{
|
mods.Add(insertMod(s, zeroStrip ? " " : ",", StringMod.AFTER), null);
|
followWithComma = false;
|
}
|
digit++;
|
--pos;
|
}
|
StringBuilder extraLeadingDigits = new StringBuilder();
|
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 StringBuilder(result.ToString().Substring(0, pos));
|
if (ShowCommas)
|
{
|
while (pos > 0)
|
{
|
if (digit > 0 && digit % 3 == 0)
|
extraLeadingDigits.Insert(pos, ',');
|
digit++;
|
--pos;
|
}
|
}
|
mods.Add(insertMod(lastOutputintDigit, extraLeadingDigits.ToString(),
|
StringMod.BEFORE), null);
|
}
|
}
|
|
private void WriteFractional(StringBuilder result, StringBuilder output)
|
{
|
int digit;
|
int strip;
|
IEnumerator<Special> it;
|
if (fractionalSpecials.Count > 0)
|
{
|
digit = result.ToString().IndexOf(".") + 1;
|
if (exponent != null)
|
strip = result.ToString().IndexOf("E") - 1;
|
else
|
strip = result.Length - 1;
|
while (strip > digit && result[strip] == '0')
|
strip--;
|
it = fractionalSpecials.GetEnumerator();
|
while (it.MoveNext())
|
{
|
Special s = it.Current;
|
if (digit >= result.Length)
|
break;
|
char resultCh = result[digit];
|
if (resultCh != '0' || s.ch == '0' || digit < strip)
|
output[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[s.pos] = ' ';
|
}
|
digit++;
|
}
|
}
|
}
|
|
/**
|
* {@inheritDoc}
|
* <p/>
|
* For a number, this is <tt>"#"</tt> for integer values, and <tt>"#.#"</tt>
|
* for floating-point values.
|
*/
|
public override void SimpleValue(StringBuilder 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 class Fraction
|
{
|
/** The denominator. */
|
private int denominator;
|
|
/** The numerator. */
|
private 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 Exception if the continued fraction failed to
|
* converge.
|
*/
|
private Fraction(double value, double epsilon, int maxDenominator, int maxIterations)
|
{
|
long overflow = Int32.MaxValue;
|
double r0 = value;
|
long a0 = (long)Math.Floor(r0);
|
if (a0 > overflow)
|
{
|
throw new ArgumentException("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;
|
bool 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 Exception("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 Exception("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 Exception 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 Denominator
|
{
|
get
|
{
|
return denominator;
|
}
|
}
|
|
/**
|
* Access the numerator.
|
* @return the numerator.
|
*/
|
public int Numerator
|
{
|
get
|
{
|
return numerator;
|
}
|
}
|
|
}
|
|
}
|
}
|
