mirror of
https://github.com/moparisthebest/mailiverse
synced 2024-11-22 16:52:24 -05:00
314 lines
11 KiB
Java
314 lines
11 KiB
Java
/*
|
|
* Copyright 2009 Google Inc.
|
|
*
|
|
* Licensed 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.
|
|
*/
|
|
|
|
/*
|
|
* 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.
|
|
*
|
|
* INCLUDES MODIFICATIONS BY RICHARD ZSCHECH AS WELL AS GOOGLE.
|
|
*/
|
|
package java.math;
|
|
|
|
import java.io.Serializable;
|
|
|
|
/**
|
|
* Immutable objects describing settings such as rounding mode and digit
|
|
* precision for the numerical operations provided by class {@link BigDecimal}.
|
|
*/
|
|
public final class MathContext implements Serializable {
|
|
|
|
/**
|
|
* A {@code MathContext} which corresponds to the IEEE 754r quadruple decimal
|
|
* precision format: 34 digit precision and {@link RoundingMode#HALF_EVEN}
|
|
* rounding.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
public static final MathContext DECIMAL64 = new MathContext(16,
|
|
RoundingMode.HALF_EVEN);
|
|
|
|
/**
|
|
* A {@code MathContext} for unlimited precision with
|
|
* {@link RoundingMode#HALF_UP} rounding.
|
|
*/
|
|
public static final MathContext UNLIMITED = new MathContext(0,
|
|
RoundingMode.HALF_UP);
|
|
|
|
/**
|
|
* 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 static final 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 static final char[] chRoundingMode = {
|
|
'r', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'M', 'o', 'd', 'e', '='};
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public MathContext(int precision) {
|
|
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}.
|
|
*/
|
|
public MathContext(int precision, RoundingMode roundingMode) {
|
|
if (precision < 0) {
|
|
// math.0C=Digits < 0
|
|
throw new IllegalArgumentException("Digits < 0"); //$NON-NLS-1$
|
|
}
|
|
if (roundingMode == null) {
|
|
// math.0D=null RoundingMode
|
|
throw new NullPointerException("null RoundingMode"); //$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.
|
|
*/
|
|
public MathContext(String val) {
|
|
if (val == null) {
|
|
throw new NullPointerException("null string");
|
|
}
|
|
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("bad string format"); //$NON-NLS-1$
|
|
}
|
|
// Parsing "precision=" String
|
|
for (i = 0; (i < chPrecision.length) && (charVal[i] == chPrecision[i]); i++) {
|
|
// empty
|
|
}
|
|
|
|
if (i < chPrecision.length) {
|
|
// math.0E=bad string format
|
|
throw new IllegalArgumentException("bad string format"); //$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("bad string format"); //$NON-NLS-1$
|
|
}
|
|
this.precision = this.precision * 10 + digit;
|
|
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("bad string format"); //$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("bad string format"); //$NON-NLS-1$
|
|
}
|
|
i++;
|
|
} while (true);
|
|
// Parsing "roundingMode="
|
|
for (j = 0; (j < chRoundingMode.length)
|
|
&& (charVal[i] == chRoundingMode[j]); i++, j++) {
|
|
// empty
|
|
}
|
|
|
|
if (j < chRoundingMode.length) {
|
|
// math.0E=bad string format
|
|
throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
|
|
}
|
|
|
|
// Parsing the value for "roundingMode"...
|
|
/*
|
|
* don't use implicit calls to RoundingMode.valueOf here, since it will break
|
|
* if enum name obfuscation is enabled.
|
|
*/
|
|
this.roundingMode = RoundingMode.valueOfExplicit(String.valueOf(charVal, i,
|
|
charVal.length - i));
|
|
}
|
|
|
|
/* Public Methods */
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@Override
|
|
public boolean equals(Object x) {
|
|
return ((x instanceof MathContext)
|
|
&& (((MathContext) x).getPrecision() == precision)
|
|
&& (((MathContext) x).getRoundingMode() == roundingMode));
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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.
|
|
*/
|
|
public RoundingMode getRoundingMode() {
|
|
return roundingMode;
|
|
}
|
|
|
|
/**
|
|
* Returns the hash code for this {@code MathContext} instance.
|
|
*
|
|
* @return the hash code for this {@code MathContext}.
|
|
*/
|
|
@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
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder(45);
|
|
|
|
sb.append(chPrecision);
|
|
sb.append(precision);
|
|
sb.append(' ');
|
|
sb.append(chRoundingMode);
|
|
sb.append(roundingMode);
|
|
return sb.toString();
|
|
}
|
|
}
|