/*
* 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 java.math;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.io.StreamCorruptedException;
import org.apache.harmony.math.internal.nls.Messages;
/**
* Immutable objects describing settings such as rounding mode and digit
* precision for the numerical operations provided by class {@link BigDecimal}.
*
* @since Android 1.0
*/
public final class MathContext implements Serializable {
// BEGIN android-note
// copied from newer version of harmony
// added final modifier
// END android-note
/* Fields */
/**
* A {@code MathContext} which corresponds to the IEEE 754r quadruple
* decimal precision format: 34 digit precision and
* {@link RoundingMode#HALF_EVEN} rounding.
*
* @since Android 1.0
*/
public static final MathContext DECIMAL128 = new MathContext(34,
RoundingMode.HALF_EVEN);
/**
* A {@code MathContext} which corresponds to the IEEE 754r single decimal
* precision format: 7 digit precision and {@link RoundingMode#HALF_EVEN}
* rounding.
*
* @since Android 1.0
*/
public static final MathContext DECIMAL32 = new MathContext(7,
RoundingMode.HALF_EVEN);
/**
* A {@code MathContext} which corresponds to the IEEE 754r double decimal
* precision format: 16 digit precision and {@link RoundingMode#HALF_EVEN}
* rounding.
*
* @since Android 1.0
*/
public static final MathContext DECIMAL64 = new MathContext(16,
RoundingMode.HALF_EVEN);
/**
* A {@code MathContext} for unlimited precision with
* {@link RoundingMode#HALF_UP} rounding.
*
* @since Android 1.0
*/
public static final MathContext UNLIMITED = new MathContext(0,
RoundingMode.HALF_UP);
/** This is the serialVersionUID used by the sun implementation */
private static final long serialVersionUID = 5579720004786848255L;
/**
* The number of digits to be used for an operation; results are rounded to
* this precision.
*/
private int precision;
/**
* A {@code RoundingMode} object which specifies the algorithm to be used
* for rounding.
*/
private RoundingMode roundingMode;
/**
* An array of {@code char} containing: {@code
* 'p','r','e','c','i','s','i','o','n','='}. It's used to improve the
* methods related to {@code String} conversion.
*
* @see #MathContext(String)
* @see #toString()
*/
private final static char[] chPrecision = { 'p', 'r', 'e', 'c', 'i', 's',
'i', 'o', 'n', '=' };
/**
* An array of {@code char} containing: {@code
* 'r','o','u','n','d','i','n','g','M','o','d','e','='}. It's used to
* improve the methods related to {@code String} conversion.
*
* @see #MathContext(String)
* @see #toString()
*/
private final static char[] chRoundingMode = { 'r', 'o', 'u', 'n', 'd',
'i', 'n', 'g', 'M', 'o', 'd', 'e', '=' };
/* Constructors */
/**
* Constructs a new {@code MathContext} with the specified precision and
* with the rounding mode {@link RoundingMode#HALF_UP HALF_UP}. If the
* precision passed is zero, then this implies that the computations have to
* be performed exact, the rounding mode in this case is irrelevant.
*
* @param precision
* the precision for the new {@code MathContext}.
* @throws IllegalArgumentException
* if {@code precision < 0}.
*
* @since Android 1.0
*/
public MathContext(int precision) {
// BEGIN android-note
// parameter names changed.
// END android-note
this(precision, RoundingMode.HALF_UP);
}
/**
* Constructs a new {@code MathContext} with the specified precision and
* with the specified rounding mode. If the precision passed is zero, then
* this implies that the computations have to be performed exact, the
* rounding mode in this case is irrelevant.
*
* @param precision
* the precision for the new {@code MathContext}.
* @param roundingMode
* the rounding mode for the new {@code MathContext}.
* @throws IllegalArgumentException
* if {@code precision < 0}.
* @throws NullPointerException
* if {@code roundingMode} is {@code null}.
*
* @since Android 1.0
*/
public MathContext(int precision, RoundingMode roundingMode) {
// BEGIN android-note
// parameter names changed.
// END android-note
if (precision < 0) {
// math.0C=Digits < 0
throw new IllegalArgumentException(Messages.getString("math.0C")); //$NON-NLS-1$
}
if (roundingMode == null) {
// math.0D=null RoundingMode
throw new NullPointerException(Messages.getString("math.0D")); //$NON-NLS-1$
}
this.precision = precision;
this.roundingMode = roundingMode;
}
/**
* Constructs a new {@code MathContext} from a string. The string has to
* specify the precision and the rounding mode to be used and has to follow
* the following syntax: "precision=<precision> roundingMode=<roundingMode>"
* This is the same form as the one returned by the {@link #toString}
* method.
*
* @param val
* a string describing the precision and rounding mode for the
* new {@code MathContext}.
* @throws IllegalArgumentException
* if the string is not in the correct format or if the
* precision specified is < 0.
*
* @since Android 1.0
*/
public MathContext(String val) {
char[] charVal = val.toCharArray();
int i; // Index of charVal
int j; // Index of chRoundingMode
int digit; // It will contain the digit parsed
if ((charVal.length < 27) || (charVal.length > 45)) {
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
// Parsing "precision=" String
for (i = 0; (i < chPrecision.length) && (charVal[i] == chPrecision[i]); i++) {
;
}
if (i < chPrecision.length) {
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
// Parsing the value for "precision="...
digit = Character.digit(charVal[i], 10);
if (digit == -1) {
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
// BEGIN android-changed
this.precision = digit;
// END android-changed
i++;
do {
digit = Character.digit(charVal[i], 10);
if (digit == -1) {
if (charVal[i] == ' ') {
// It parsed all the digits
i++;
break;
}
// It isn't a valid digit, and isn't a white space
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
// Accumulating the value parsed
this.precision = this.precision * 10 + digit;
if (this.precision < 0) {
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
i++;
} while (true);
// Parsing "roundingMode="
for (j = 0; (j < chRoundingMode.length)
&& (charVal[i] == chRoundingMode[j]); i++, j++) {
;
}
if (j < chRoundingMode.length) {
// math.0E=bad string format
throw new IllegalArgumentException(Messages.getString("math.0E")); //$NON-NLS-1$
}
// Parsing the value for "roundingMode"...
this.roundingMode = RoundingMode.valueOf(String.valueOf(charVal, i,
charVal.length - i));
}
/* Public Methods */
/**
* Returns the precision. The precision is the number of digits used for an
* operation. Results are rounded to this precision. The precision is
* guaranteed to be non negative. If the precision is zero, then the
* computations have to be performed exact, results are not rounded in this
* case.
*
* @return the precision.
*
* @since Android 1.0
*/
public int getPrecision() {
return precision;
}
/**
* Returns the rounding mode. The rounding mode is the strategy to be used
* to round results.
* <p>
* The rounding mode is one of
* {@link RoundingMode#UP},
* {@link RoundingMode#DOWN},
* {@link RoundingMode#CEILING},
* {@link RoundingMode#FLOOR},
* {@link RoundingMode#HALF_UP},
* {@link RoundingMode#HALF_DOWN},
* {@link RoundingMode#HALF_EVEN}, or
* {@link RoundingMode#UNNECESSARY}.
*
* @return the rounding mode.
*
* @since Android 1.0
*/
public RoundingMode getRoundingMode() {
return roundingMode;
}
/**
* Returns true if x is a {@code MathContext} with the same precision
* setting and the same rounding mode as this {@code MathContext} instance.
*
* @param x
* object to be compared.
* @return {@code true} if this {@code MathContext} instance is equal to the
* {@code x} argument; {@code false} otherwise.
*
* @since Android 1.0
*/
@Override
public boolean equals(Object x) {
return ((x instanceof MathContext)
&& (((MathContext) x).getPrecision() == precision) && (((MathContext) x)
.getRoundingMode() == roundingMode));
}
/**
* Returns the hash code for this {@code MathContext} instance.
*
* @return the hash code for this {@code MathContext}.
*
* @since Android 1.0
*/
@Override
public int hashCode() {
// Make place for the necessary bits to represent 8 rounding modes
return ((precision << 3) | roundingMode.ordinal());
}
/**
* Returns the string representation for this {@code MathContext} instance.
* The string has the form
* {@code
* "precision=<precision> roundingMode=<roundingMode>"
* } where {@code <precision>} is an integer describing the number
* of digits used for operations and {@code <roundingMode>} is the
* string representation of the rounding mode.
*
* @return a string representation for this {@code MathContext} instance
* @since Android 1.0
*/
@Override
public String toString() {
StringBuffer sb = new StringBuffer(45);
sb.append(chPrecision);
sb.append(precision);
sb.append(' ');
sb.append(chRoundingMode);
sb.append(roundingMode);
return sb.toString();
}
/**
* Makes checks upon deserialization of a {@code MathContext} instance.
* Checks whether {@code precision >= 0} and {@code roundingMode != null}
*
* @throws StreamCorruptedException
* if {@code precision < 0}
* @throws StreamCorruptedException
* if {@code roundingMode == null}
*/
private void readObject(ObjectInputStream s) throws IOException,
ClassNotFoundException {
s.defaultReadObject();
if (precision < 0) {
// math.0F=bad precision value
throw new StreamCorruptedException(Messages.getString("math.0F")); //$NON-NLS-1$
}
if (roundingMode == null) {
// math.10=null roundingMode
throw new StreamCorruptedException(Messages.getString("math.10")); //$NON-NLS-1$
}
}
}
|
