    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.math.util;
    018
    019
    020    import java.io.Serializable;
    021    import java.math.BigDecimal;
    022    import java.math.BigInteger;
    023    import java.math.MathContext;
    024    import java.math.RoundingMode;
    025
    026    import org.apache.commons.math.Field;
    027    import org.apache.commons.math.FieldElement;
    028
    029    /**
    030     * Arbitrary precision decimal number.
    031     * <p>
    032     * This class is a simple wrapper around the standard <code>BigDecimal</code>
    033     * in order to implement the {@link FieldElement} interface.
    034     * </p>
    035     * @since 2.0
    036     * @version $Revision: 925812 $ $Date: 2010-03-21 16:49:31 +0100 (dim. 21 mars 2010) $
    037     */
    038    public class BigReal implements FieldElement<BigReal>, Comparable<BigReal>, Serializable {
    039
    040        /** A big real representing 0. */
    041        public static final BigReal ZERO = new BigReal(BigDecimal.ZERO);
    042
    043        /** A big real representing 1. */
    044        public static final BigReal ONE = new BigReal(BigDecimal.ONE);
    045
    046        /** Serializable version identifier. */
    047        private static final long serialVersionUID = 4984534880991310382L;
    048
    049        /** Underlying BigDecimal. */
    050        private final BigDecimal d;
    051
    052        /** Rounding mode for divisions. **/
    053        private RoundingMode roundingMode = RoundingMode.HALF_UP;
    054
    055        /*** BigDecimal scale ***/
    056        private int scale = 64;
    057
    058        /** Build an instance from a BigDecimal.
    059         * @param val value of the instance
    060         */
    061        public BigReal(BigDecimal val) {
    062            d =  val;
    063        }
    064
    065        /** Build an instance from a BigInteger.
    066         * @param val value of the instance
    067         */
    068        public BigReal(BigInteger val) {
    069            d = new BigDecimal(val);
    070        }
    071
    072        /** Build an instance from an unscaled BigInteger.
    073         * @param unscaledVal unscaled value
    074         * @param scale scale to use
    075         */
    076        public BigReal(BigInteger unscaledVal, int scale) {
    077            d = new BigDecimal(unscaledVal, scale);
    078        }
    079
    080        /** Build an instance from an unscaled BigInteger.
    081         * @param unscaledVal unscaled value
    082         * @param scale scale to use
    083         * @param mc to used
    084         */
    085        public BigReal(BigInteger unscaledVal, int scale, MathContext mc) {
    086            d = new BigDecimal(unscaledVal, scale, mc);
    087        }
    088
    089        /** Build an instance from a BigInteger.
    090         * @param val value of the instance
    091         * @param mc context to use
    092         */
    093        public BigReal(BigInteger val, MathContext mc) {
    094            d = new BigDecimal(val, mc);
    095        }
    096
    097        /** Build an instance from a characters representation.
    098         * @param in character representation of the value
    099         */
    100        public BigReal(char[] in) {
    101            d = new BigDecimal(in);
    102        }
    103
    104        /** Build an instance from a characters representation.
    105         * @param in character representation of the value
    106         * @param offset offset of the first character to analyze
    107         * @param len length of the array slice to analyze
    108         */
    109        public BigReal(char[] in, int offset, int len) {
    110            d = new BigDecimal(in, offset, len);
    111        }
    112
    113        /** Build an instance from a characters representation.
    114         * @param in character representation of the value
    115         * @param offset offset of the first character to analyze
    116         * @param len length of the array slice to analyze
    117         * @param mc context to use
    118         */
    119        public BigReal(char[] in, int offset, int len, MathContext mc) {
    120            d = new BigDecimal(in, offset, len, mc);
    121        }
    122
    123        /** Build an instance from a characters representation.
    124         * @param in character representation of the value
    125         * @param mc context to use
    126         */
    127        public BigReal(char[] in, MathContext mc) {
    128            d = new BigDecimal(in, mc);
    129        }
    130
    131        /** Build an instance from a double.
    132         * @param val value of the instance
    133         */
    134        public BigReal(double val) {
    135            d = new BigDecimal(val);
    136        }
    137
    138        /** Build an instance from a double.
    139         * @param val value of the instance
    140         * @param mc context to use
    141         */
    142        public BigReal(double val, MathContext mc) {
    143            d = new BigDecimal(val, mc);
    144        }
    145
    146        /** Build an instance from an int.
    147         * @param val value of the instance
    148         */
    149        public BigReal(int val) {
    150            d = new BigDecimal(val);
    151        }
    152
    153        /** Build an instance from an int.
    154         * @param val value of the instance
    155         * @param mc context to use
    156         */
    157        public BigReal(int val, MathContext mc) {
    158            d = new BigDecimal(val, mc);
    159        }
    160
    161        /** Build an instance from a long.
    162         * @param val value of the instance
    163         */
    164        public BigReal(long val) {
    165            d = new BigDecimal(val);
    166        }
    167
    168        /** Build an instance from a long.
    169         * @param val value of the instance
    170         * @param mc context to use
    171         */
    172        public BigReal(long val, MathContext mc) {
    173            d = new BigDecimal(val, mc);
    174        }
    175
    176        /** Build an instance from a String representation.
    177         * @param val character representation of the value
    178         */
    179        public BigReal(String val) {
    180            d = new BigDecimal(val);
    181        }
    182
    183        /** Build an instance from a String representation.
    184         * @param val character representation of the value
    185         * @param mc context to use
    186         */
    187        public BigReal(String val, MathContext mc)  {
    188            d = new BigDecimal(val, mc);
    189        }
    190
    191        /***
    192         * Gets the rounding mode for division operations
    193         * The default is {@code RoundingMode.HALF_UP}
    194         * @return the rounding mode.
    195         * @since 2.1
    196         */
    197        public RoundingMode getRoundingMode() {
    198            return roundingMode;
    199        }
    200
    201        /***
    202         * Sets the rounding mode for decimal divisions.
    203         * @param roundingMode rounding mode for decimal divisions
    204         * @since 2.1
    205         */
    206        public void setRoundingMode(RoundingMode roundingMode) {
    207            this.roundingMode = roundingMode;
    208        }
    209
    210        /***
    211         * Sets the scale for division operations.
    212         * The default is 64
    213         * @return the scale
    214         * @since 2.1
    215         */
    216        public int getScale() {
    217            return scale;
    218        }
    219
    220        /***
    221         * Sets the scale for division operations.
    222         * @param scale scale for division operations
    223         * @since 2.1
    224         */
    225        public void setScale(int scale) {
    226            this.scale = scale;
    227        }
    228
    229        /** {@inheritDoc} */
    230        public BigReal add(BigReal a) {
    231            return new BigReal(d.add(a.d));
    232        }
    233
    234        /** {@inheritDoc} */
    235        public BigReal subtract(BigReal a) {
    236            return new BigReal(d.subtract(a.d));
    237        }
    238
    239        /** {@inheritDoc} */
    240        public BigReal divide(BigReal a) throws ArithmeticException {
    241            return new BigReal(d.divide(a.d, scale, roundingMode));
    242        }
    243
    244        /** {@inheritDoc} */
    245        public BigReal multiply(BigReal a) {
    246            return new BigReal(d.multiply(a.d));
    247        }
    248
    249        /** {@inheritDoc} */
    250        public int compareTo(BigReal a) {
    251            return d.compareTo(a.d);
    252        }
    253
    254        /** Get the double value corresponding to the instance.
    255         * @return double value corresponding to the instance
    256         */
    257        public double doubleValue() {
    258            return d.doubleValue();
    259        }
    260
    261        /** Get the BigDecimal value corresponding to the instance.
    262         * @return BigDecimal value corresponding to the instance
    263         */
    264        public BigDecimal bigDecimalValue() {
    265            return d;
    266        }
    267
    268        /** {@inheritDoc} */
    269        @Override
    270        public boolean equals(Object other) {
    271            if (this == other){
    272                return true;
    273            }
    274
    275            if (other instanceof BigReal){
    276                return d.equals(((BigReal) other).d);
    277            }
    278            return false;
    279        }
    280
    281        /** {@inheritDoc} */
    282        @Override
    283        public int hashCode() {
    284            return d.hashCode();
    285        }
    286
    287        /** {@inheritDoc} */
    288        public Field<BigReal> getField() {
    289            return BigRealField.getInstance();
    290        }
    291
    292    }