You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
641 lines
22 KiB
641 lines
22 KiB
/*
|
|
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
|
|
* (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
|
|
*
|
|
* The original version of this source code and documentation is copyrighted
|
|
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
|
|
* materials are provided under terms of a License Agreement between Taligent
|
|
* and Sun. This technology is protected by multiple US and International
|
|
* patents. This notice and attribution to Taligent may not be removed.
|
|
* Taligent is a registered trademark of Taligent, Inc.
|
|
*
|
|
*/
|
|
|
|
package java.text;
|
|
|
|
import java.io.InvalidObjectException;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.util.Arrays;
|
|
|
|
/**
|
|
* A <code>ChoiceFormat</code> allows you to attach a format to a range of numbers.
|
|
* It is generally used in a <code>MessageFormat</code> for handling plurals.
|
|
* The choice is specified with an ascending list of doubles, where each item
|
|
* specifies a half-open interval up to the next item:
|
|
* <blockquote>
|
|
* <pre>
|
|
* X matches j if and only if limit[j] ≤ X < limit[j+1]
|
|
* </pre>
|
|
* </blockquote>
|
|
* If there is no match, then either the first or last index is used, depending
|
|
* on whether the number (X) is too low or too high. If the limit array is not
|
|
* in ascending order, the results of formatting will be incorrect. ChoiceFormat
|
|
* also accepts <code>\u221E</code> as equivalent to infinity(INF).
|
|
*
|
|
* <p>
|
|
* <strong>Note:</strong>
|
|
* <code>ChoiceFormat</code> differs from the other <code>Format</code>
|
|
* classes in that you create a <code>ChoiceFormat</code> object with a
|
|
* constructor (not with a <code>getInstance</code> style factory
|
|
* method). The factory methods aren't necessary because <code>ChoiceFormat</code>
|
|
* doesn't require any complex setup for a given locale. In fact,
|
|
* <code>ChoiceFormat</code> doesn't implement any locale specific behavior.
|
|
*
|
|
* <p>
|
|
* When creating a <code>ChoiceFormat</code>, you must specify an array of formats
|
|
* and an array of limits. The length of these arrays must be the same.
|
|
* For example,
|
|
* <ul>
|
|
* <li>
|
|
* <em>limits</em> = {1,2,3,4,5,6,7}<br>
|
|
* <em>formats</em> = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
|
|
* <li>
|
|
* <em>limits</em> = {0, 1, ChoiceFormat.nextDouble(1)}<br>
|
|
* <em>formats</em> = {"no files", "one file", "many files"}<br>
|
|
* (<code>nextDouble</code> can be used to get the next higher double, to
|
|
* make the half-open interval.)
|
|
* </ul>
|
|
*
|
|
* <p>
|
|
* Here is a simple example that shows formatting and parsing:
|
|
* <blockquote>
|
|
* <pre>{@code
|
|
* double[] limits = {1,2,3,4,5,6,7};
|
|
* String[] dayOfWeekNames = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
|
|
* ChoiceFormat form = new ChoiceFormat(limits, dayOfWeekNames);
|
|
* ParsePosition status = new ParsePosition(0);
|
|
* for (double i = 0.0; i <= 8.0; ++i) {
|
|
* status.setIndex(0);
|
|
* System.out.println(i + " -> " + form.format(i) + " -> "
|
|
* + form.parse(form.format(i),status));
|
|
* }
|
|
* }</pre>
|
|
* </blockquote>
|
|
* Here is a more complex example, with a pattern format:
|
|
* <blockquote>
|
|
* <pre>{@code
|
|
* double[] filelimits = {0,1,2};
|
|
* String[] filepart = {"are no files","is one file","are {2} files"};
|
|
* ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
|
|
* Format[] testFormats = {fileform, null, NumberFormat.getInstance()};
|
|
* MessageFormat pattform = new MessageFormat("There {0} on {1}");
|
|
* pattform.setFormats(testFormats);
|
|
* Object[] testArgs = {null, "ADisk", null};
|
|
* for (int i = 0; i < 4; ++i) {
|
|
* testArgs[0] = new Integer(i);
|
|
* testArgs[2] = testArgs[0];
|
|
* System.out.println(pattform.format(testArgs));
|
|
* }
|
|
* }</pre>
|
|
* </blockquote>
|
|
* <p>
|
|
* Specifying a pattern for ChoiceFormat objects is fairly straightforward.
|
|
* For example:
|
|
* <blockquote>
|
|
* <pre>{@code
|
|
* ChoiceFormat fmt = new ChoiceFormat(
|
|
* "-1#is negative| 0#is zero or fraction | 1#is one |1.0<is 1+ |2#is two |2<is more than 2.");
|
|
* System.out.println("Formatter Pattern : " + fmt.toPattern());
|
|
*
|
|
* System.out.println("Format with -INF : " + fmt.format(Double.NEGATIVE_INFINITY));
|
|
* System.out.println("Format with -1.0 : " + fmt.format(-1.0));
|
|
* System.out.println("Format with 0 : " + fmt.format(0));
|
|
* System.out.println("Format with 0.9 : " + fmt.format(0.9));
|
|
* System.out.println("Format with 1.0 : " + fmt.format(1));
|
|
* System.out.println("Format with 1.5 : " + fmt.format(1.5));
|
|
* System.out.println("Format with 2 : " + fmt.format(2));
|
|
* System.out.println("Format with 2.1 : " + fmt.format(2.1));
|
|
* System.out.println("Format with NaN : " + fmt.format(Double.NaN));
|
|
* System.out.println("Format with +INF : " + fmt.format(Double.POSITIVE_INFINITY));
|
|
* }</pre>
|
|
* </blockquote>
|
|
* And the output result would be like the following:
|
|
* <blockquote>
|
|
* <pre>{@code
|
|
* Format with -INF : is negative
|
|
* Format with -1.0 : is negative
|
|
* Format with 0 : is zero or fraction
|
|
* Format with 0.9 : is zero or fraction
|
|
* Format with 1.0 : is one
|
|
* Format with 1.5 : is 1+
|
|
* Format with 2 : is two
|
|
* Format with 2.1 : is more than 2.
|
|
* Format with NaN : is negative
|
|
* Format with +INF : is more than 2.
|
|
* }</pre>
|
|
* </blockquote>
|
|
*
|
|
* <h3><a name="synchronization">Synchronization</a></h3>
|
|
*
|
|
* <p>
|
|
* Choice formats are not synchronized.
|
|
* It is recommended to create separate format instances for each thread.
|
|
* If multiple threads access a format concurrently, it must be synchronized
|
|
* externally.
|
|
*
|
|
*
|
|
* @see DecimalFormat
|
|
* @see MessageFormat
|
|
* @author Mark Davis
|
|
*/
|
|
public class ChoiceFormat extends NumberFormat {
|
|
|
|
// Proclaim serial compatibility with 1.1 FCS
|
|
private static final long serialVersionUID = 1795184449645032964L;
|
|
|
|
/**
|
|
* Sets the pattern.
|
|
* @param newPattern See the class description.
|
|
*/
|
|
public void applyPattern(String newPattern) {
|
|
StringBuffer[] segments = new StringBuffer[2];
|
|
for (int i = 0; i < segments.length; ++i) {
|
|
segments[i] = new StringBuffer();
|
|
}
|
|
double[] newChoiceLimits = new double[30];
|
|
String[] newChoiceFormats = new String[30];
|
|
int count = 0;
|
|
int part = 0;
|
|
double startValue = 0;
|
|
double oldStartValue = Double.NaN;
|
|
boolean inQuote = false;
|
|
for (int i = 0; i < newPattern.length(); ++i) {
|
|
char ch = newPattern.charAt(i);
|
|
if (ch=='\'') {
|
|
// Check for "''" indicating a literal quote
|
|
if ((i+1)<newPattern.length() && newPattern.charAt(i+1)==ch) {
|
|
segments[part].append(ch);
|
|
++i;
|
|
} else {
|
|
inQuote = !inQuote;
|
|
}
|
|
} else if (inQuote) {
|
|
segments[part].append(ch);
|
|
} else if (ch == '<' || ch == '#' || ch == '\u2264') {
|
|
if (segments[0].length() == 0) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
try {
|
|
String tempBuffer = segments[0].toString();
|
|
if (tempBuffer.equals("\u221E")) {
|
|
startValue = Double.POSITIVE_INFINITY;
|
|
} else if (tempBuffer.equals("-\u221E")) {
|
|
startValue = Double.NEGATIVE_INFINITY;
|
|
} else {
|
|
startValue = Double.valueOf(segments[0].toString()).doubleValue();
|
|
}
|
|
} catch (Exception e) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (ch == '<' && startValue != Double.POSITIVE_INFINITY &&
|
|
startValue != Double.NEGATIVE_INFINITY) {
|
|
startValue = nextDouble(startValue);
|
|
}
|
|
if (startValue <= oldStartValue) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
segments[0].setLength(0);
|
|
part = 1;
|
|
} else if (ch == '|') {
|
|
if (count == newChoiceLimits.length) {
|
|
newChoiceLimits = doubleArraySize(newChoiceLimits);
|
|
newChoiceFormats = doubleArraySize(newChoiceFormats);
|
|
}
|
|
newChoiceLimits[count] = startValue;
|
|
newChoiceFormats[count] = segments[1].toString();
|
|
++count;
|
|
oldStartValue = startValue;
|
|
segments[1].setLength(0);
|
|
part = 0;
|
|
} else {
|
|
segments[part].append(ch);
|
|
}
|
|
}
|
|
// clean up last one
|
|
if (part == 1) {
|
|
if (count == newChoiceLimits.length) {
|
|
newChoiceLimits = doubleArraySize(newChoiceLimits);
|
|
newChoiceFormats = doubleArraySize(newChoiceFormats);
|
|
}
|
|
newChoiceLimits[count] = startValue;
|
|
newChoiceFormats[count] = segments[1].toString();
|
|
++count;
|
|
}
|
|
choiceLimits = new double[count];
|
|
System.arraycopy(newChoiceLimits, 0, choiceLimits, 0, count);
|
|
choiceFormats = new String[count];
|
|
System.arraycopy(newChoiceFormats, 0, choiceFormats, 0, count);
|
|
}
|
|
|
|
/**
|
|
* Gets the pattern.
|
|
*
|
|
* @return the pattern string
|
|
*/
|
|
public String toPattern() {
|
|
StringBuffer result = new StringBuffer();
|
|
for (int i = 0; i < choiceLimits.length; ++i) {
|
|
if (i != 0) {
|
|
result.append('|');
|
|
}
|
|
// choose based upon which has less precision
|
|
// approximate that by choosing the closest one to an integer.
|
|
// could do better, but it's not worth it.
|
|
double less = previousDouble(choiceLimits[i]);
|
|
double tryLessOrEqual = Math.abs(Math.IEEEremainder(choiceLimits[i], 1.0d));
|
|
double tryLess = Math.abs(Math.IEEEremainder(less, 1.0d));
|
|
|
|
if (tryLessOrEqual < tryLess) {
|
|
result.append(""+choiceLimits[i]);
|
|
result.append('#');
|
|
} else {
|
|
if (choiceLimits[i] == Double.POSITIVE_INFINITY) {
|
|
result.append("\u221E");
|
|
} else if (choiceLimits[i] == Double.NEGATIVE_INFINITY) {
|
|
result.append("-\u221E");
|
|
} else {
|
|
result.append(""+less);
|
|
}
|
|
result.append('<');
|
|
}
|
|
// Append choiceFormats[i], using quotes if there are special characters.
|
|
// Single quotes themselves must be escaped in either case.
|
|
String text = choiceFormats[i];
|
|
boolean needQuote = text.indexOf('<') >= 0
|
|
|| text.indexOf('#') >= 0
|
|
|| text.indexOf('\u2264') >= 0
|
|
|| text.indexOf('|') >= 0;
|
|
if (needQuote) result.append('\'');
|
|
if (text.indexOf('\'') < 0) result.append(text);
|
|
else {
|
|
for (int j=0; j<text.length(); ++j) {
|
|
char c = text.charAt(j);
|
|
result.append(c);
|
|
if (c == '\'') result.append(c);
|
|
}
|
|
}
|
|
if (needQuote) result.append('\'');
|
|
}
|
|
return result.toString();
|
|
}
|
|
|
|
/**
|
|
* Constructs with limits and corresponding formats based on the pattern.
|
|
*
|
|
* @param newPattern the new pattern string
|
|
* @see #applyPattern
|
|
*/
|
|
public ChoiceFormat(String newPattern) {
|
|
applyPattern(newPattern);
|
|
}
|
|
|
|
/**
|
|
* Constructs with the limits and the corresponding formats.
|
|
*
|
|
* @param limits limits in ascending order
|
|
* @param formats corresponding format strings
|
|
* @see #setChoices
|
|
*/
|
|
public ChoiceFormat(double[] limits, String[] formats) {
|
|
setChoices(limits, formats);
|
|
}
|
|
|
|
/**
|
|
* Set the choices to be used in formatting.
|
|
* @param limits contains the top value that you want
|
|
* parsed with that format, and should be in ascending sorted order. When
|
|
* formatting X, the choice will be the i, where
|
|
* limit[i] ≤ X {@literal <} limit[i+1].
|
|
* If the limit array is not in ascending order, the results of formatting
|
|
* will be incorrect.
|
|
* @param formats are the formats you want to use for each limit.
|
|
* They can be either Format objects or Strings.
|
|
* When formatting with object Y,
|
|
* if the object is a NumberFormat, then ((NumberFormat) Y).format(X)
|
|
* is called. Otherwise Y.toString() is called.
|
|
*/
|
|
public void setChoices(double[] limits, String formats[]) {
|
|
if (limits.length != formats.length) {
|
|
throw new IllegalArgumentException(
|
|
"Array and limit arrays must be of the same length.");
|
|
}
|
|
choiceLimits = Arrays.copyOf(limits, limits.length);
|
|
choiceFormats = Arrays.copyOf(formats, formats.length);
|
|
}
|
|
|
|
/**
|
|
* Get the limits passed in the constructor.
|
|
* @return the limits.
|
|
*/
|
|
public double[] getLimits() {
|
|
double[] newLimits = Arrays.copyOf(choiceLimits, choiceLimits.length);
|
|
return newLimits;
|
|
}
|
|
|
|
/**
|
|
* Get the formats passed in the constructor.
|
|
* @return the formats.
|
|
*/
|
|
public Object[] getFormats() {
|
|
Object[] newFormats = Arrays.copyOf(choiceFormats, choiceFormats.length);
|
|
return newFormats;
|
|
}
|
|
|
|
// Overrides
|
|
|
|
/**
|
|
* Specialization of format. This method really calls
|
|
* <code>format(double, StringBuffer, FieldPosition)</code>
|
|
* thus the range of longs that are supported is only equal to
|
|
* the range that can be stored by double. This will never be
|
|
* a practical limitation.
|
|
*/
|
|
public StringBuffer format(long number, StringBuffer toAppendTo,
|
|
FieldPosition status) {
|
|
return format((double)number, toAppendTo, status);
|
|
}
|
|
|
|
/**
|
|
* Returns pattern with formatted double.
|
|
* @param number number to be formatted and substituted.
|
|
* @param toAppendTo where text is appended.
|
|
* @param status ignore no useful status is returned.
|
|
*/
|
|
public StringBuffer format(double number, StringBuffer toAppendTo,
|
|
FieldPosition status) {
|
|
// find the number
|
|
int i;
|
|
for (i = 0; i < choiceLimits.length; ++i) {
|
|
if (!(number >= choiceLimits[i])) {
|
|
// same as number < choiceLimits, except catchs NaN
|
|
break;
|
|
}
|
|
}
|
|
--i;
|
|
if (i < 0) i = 0;
|
|
// return either a formatted number, or a string
|
|
return toAppendTo.append(choiceFormats[i]);
|
|
}
|
|
|
|
/**
|
|
* Parses a Number from the input text.
|
|
* @param text the source text.
|
|
* @param status an input-output parameter. On input, the
|
|
* status.index field indicates the first character of the
|
|
* source text that should be parsed. On exit, if no error
|
|
* occurred, status.index is set to the first unparsed character
|
|
* in the source text. On exit, if an error did occur,
|
|
* status.index is unchanged and status.errorIndex is set to the
|
|
* first index of the character that caused the parse to fail.
|
|
* @return A Number representing the value of the number parsed.
|
|
*/
|
|
public Number parse(String text, ParsePosition status) {
|
|
// find the best number (defined as the one with the longest parse)
|
|
int start = status.index;
|
|
int furthest = start;
|
|
double bestNumber = Double.NaN;
|
|
double tempNumber = 0.0;
|
|
for (int i = 0; i < choiceFormats.length; ++i) {
|
|
String tempString = choiceFormats[i];
|
|
if (text.regionMatches(start, tempString, 0, tempString.length())) {
|
|
status.index = start + tempString.length();
|
|
tempNumber = choiceLimits[i];
|
|
if (status.index > furthest) {
|
|
furthest = status.index;
|
|
bestNumber = tempNumber;
|
|
if (furthest == text.length()) break;
|
|
}
|
|
}
|
|
}
|
|
status.index = furthest;
|
|
if (status.index == start) {
|
|
status.errorIndex = furthest;
|
|
}
|
|
return new Double(bestNumber);
|
|
}
|
|
|
|
/**
|
|
* Finds the least double greater than {@code d}.
|
|
* If {@code NaN}, returns same value.
|
|
* <p>Used to make half-open intervals.
|
|
*
|
|
* @param d the reference value
|
|
* @return the least double value greather than {@code d}
|
|
* @see #previousDouble
|
|
*/
|
|
public static final double nextDouble (double d) {
|
|
return nextDouble(d,true);
|
|
}
|
|
|
|
/**
|
|
* Finds the greatest double less than {@code d}.
|
|
* If {@code NaN}, returns same value.
|
|
*
|
|
* @param d the reference value
|
|
* @return the greatest double value less than {@code d}
|
|
* @see #nextDouble
|
|
*/
|
|
public static final double previousDouble (double d) {
|
|
return nextDouble(d,false);
|
|
}
|
|
|
|
/**
|
|
* Overrides Cloneable
|
|
*/
|
|
public Object clone()
|
|
{
|
|
ChoiceFormat other = (ChoiceFormat) super.clone();
|
|
// for primitives or immutables, shallow clone is enough
|
|
other.choiceLimits = choiceLimits.clone();
|
|
other.choiceFormats = choiceFormats.clone();
|
|
return other;
|
|
}
|
|
|
|
/**
|
|
* Generates a hash code for the message format object.
|
|
*/
|
|
public int hashCode() {
|
|
int result = choiceLimits.length;
|
|
if (choiceFormats.length > 0) {
|
|
// enough for reasonable distribution
|
|
result ^= choiceFormats[choiceFormats.length-1].hashCode();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Equality comparision between two
|
|
*/
|
|
public boolean equals(Object obj) {
|
|
if (obj == null) return false;
|
|
if (this == obj) // quick check
|
|
return true;
|
|
if (getClass() != obj.getClass())
|
|
return false;
|
|
ChoiceFormat other = (ChoiceFormat) obj;
|
|
return (Arrays.equals(choiceLimits, other.choiceLimits)
|
|
&& Arrays.equals(choiceFormats, other.choiceFormats));
|
|
}
|
|
|
|
/**
|
|
* After reading an object from the input stream, do a simple verification
|
|
* to maintain class invariants.
|
|
* @throws InvalidObjectException if the objects read from the stream is invalid.
|
|
*/
|
|
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
|
|
in.defaultReadObject();
|
|
if (choiceLimits.length != choiceFormats.length) {
|
|
throw new InvalidObjectException(
|
|
"limits and format arrays of different length.");
|
|
}
|
|
}
|
|
|
|
// ===============privates===========================
|
|
|
|
/**
|
|
* A list of lower bounds for the choices. The formatter will return
|
|
* <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
|
|
* <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
|
|
* @serial
|
|
*/
|
|
private double[] choiceLimits;
|
|
|
|
/**
|
|
* A list of choice strings. The formatter will return
|
|
* <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
|
|
* <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
|
|
* @serial
|
|
*/
|
|
private String[] choiceFormats;
|
|
|
|
/*
|
|
static final long SIGN = 0x8000000000000000L;
|
|
static final long EXPONENT = 0x7FF0000000000000L;
|
|
static final long SIGNIFICAND = 0x000FFFFFFFFFFFFFL;
|
|
|
|
private static double nextDouble (double d, boolean positive) {
|
|
if (Double.isNaN(d) || Double.isInfinite(d)) {
|
|
return d;
|
|
}
|
|
long bits = Double.doubleToLongBits(d);
|
|
long significand = bits & SIGNIFICAND;
|
|
if (bits < 0) {
|
|
significand |= (SIGN | EXPONENT);
|
|
}
|
|
long exponent = bits & EXPONENT;
|
|
if (positive) {
|
|
significand += 1;
|
|
// FIXME fix overflow & underflow
|
|
} else {
|
|
significand -= 1;
|
|
// FIXME fix overflow & underflow
|
|
}
|
|
bits = exponent | (significand & ~EXPONENT);
|
|
return Double.longBitsToDouble(bits);
|
|
}
|
|
*/
|
|
|
|
static final long SIGN = 0x8000000000000000L;
|
|
static final long EXPONENT = 0x7FF0000000000000L;
|
|
static final long POSITIVEINFINITY = 0x7FF0000000000000L;
|
|
|
|
/**
|
|
* Finds the least double greater than {@code d} (if {@code positive} is
|
|
* {@code true}), or the greatest double less than {@code d} (if
|
|
* {@code positive} is {@code false}).
|
|
* If {@code NaN}, returns same value.
|
|
*
|
|
* Does not affect floating-point flags,
|
|
* provided these member functions do not:
|
|
* Double.longBitsToDouble(long)
|
|
* Double.doubleToLongBits(double)
|
|
* Double.isNaN(double)
|
|
*
|
|
* @param d the reference value
|
|
* @param positive {@code true} if the least double is desired;
|
|
* {@code false} otherwise
|
|
* @return the least or greater double value
|
|
*/
|
|
public static double nextDouble (double d, boolean positive) {
|
|
|
|
/* filter out NaN's */
|
|
if (Double.isNaN(d)) {
|
|
return d;
|
|
}
|
|
|
|
/* zero's are also a special case */
|
|
if (d == 0.0) {
|
|
double smallestPositiveDouble = Double.longBitsToDouble(1L);
|
|
if (positive) {
|
|
return smallestPositiveDouble;
|
|
} else {
|
|
return -smallestPositiveDouble;
|
|
}
|
|
}
|
|
|
|
/* if entering here, d is a nonzero value */
|
|
|
|
/* hold all bits in a long for later use */
|
|
long bits = Double.doubleToLongBits(d);
|
|
|
|
/* strip off the sign bit */
|
|
long magnitude = bits & ~SIGN;
|
|
|
|
/* if next double away from zero, increase magnitude */
|
|
if ((bits > 0) == positive) {
|
|
if (magnitude != POSITIVEINFINITY) {
|
|
magnitude += 1;
|
|
}
|
|
}
|
|
/* else decrease magnitude */
|
|
else {
|
|
magnitude -= 1;
|
|
}
|
|
|
|
/* restore sign bit and return */
|
|
long signbit = bits & SIGN;
|
|
return Double.longBitsToDouble (magnitude | signbit);
|
|
}
|
|
|
|
private static double[] doubleArraySize(double[] array) {
|
|
int oldSize = array.length;
|
|
double[] newArray = new double[oldSize * 2];
|
|
System.arraycopy(array, 0, newArray, 0, oldSize);
|
|
return newArray;
|
|
}
|
|
|
|
private String[] doubleArraySize(String[] array) {
|
|
int oldSize = array.length;
|
|
String[] newArray = new String[oldSize * 2];
|
|
System.arraycopy(array, 0, newArray, 0, oldSize);
|
|
return newArray;
|
|
}
|
|
|
|
}
|