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    }