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    
025    import org.apache.commons.math.Field;
026    import org.apache.commons.math.FieldElement;
027    
028    /**
029     * Arbitrary precision decimal number.
030     * <p>
031     * This class is a simple wrapper around the standard <code>BigDecimal</code>
032     * in order to implement the {@link FieldElement} interface.
033     * </p>
034     * @since 2.0
035     * @version $Revision: 795963 $ $Date: 2009-07-20 15:23:43 -0400 (Mon, 20 Jul 2009) $
036     */
037    public class BigReal implements FieldElement<BigReal>, Comparable<BigReal>, Serializable {
038    
039        /** Serializable version identifier. */
040        private static final long serialVersionUID = 7887631840434052850L;
041    
042        /** A big real representing 0. */
043        public static final BigReal ZERO = new BigReal(BigDecimal.ZERO);
044    
045        /** A big real representing 1. */
046        public static final BigReal ONE = new BigReal(BigDecimal.ONE);
047    
048        /** Underlying BigDecimal. */
049        private final BigDecimal d;
050    
051        /** Build an instance from a BigDecimal.
052         * @param val value of the instance
053         */
054        public BigReal(BigDecimal val) {
055            d =  val;
056        }
057    
058        /** Build an instance from a BigInteger.
059         * @param val value of the instance
060         */
061        public BigReal(BigInteger val) {
062            d = new BigDecimal(val);
063        }
064    
065        /** Build an instance from an unscaled BigInteger.
066         * @param unscaledVal unscaled value
067         * @param scale scale to use
068         */
069        public BigReal(BigInteger unscaledVal, int scale) {
070            d = new BigDecimal(unscaledVal, scale);
071        }
072    
073        /** Build an instance from an unscaled BigInteger.
074         * @param unscaledVal unscaled value
075         * @param scale scale to use
076         * @param mc to used
077         */
078        public BigReal(BigInteger unscaledVal, int scale, MathContext mc) {
079            d = new BigDecimal(unscaledVal, scale, mc);
080        }
081    
082        /** Build an instance from a BigInteger.
083         * @param val value of the instance
084         * @param mc context to use
085         */
086        public BigReal(BigInteger val, MathContext mc) {
087            d = new BigDecimal(val, mc);
088        }
089    
090        /** Build an instance from a characters representation.
091         * @param in character representation of the value
092         */
093        public BigReal(char[] in) {
094            d = new BigDecimal(in);
095        }
096    
097        /** Build an instance from a characters representation.
098         * @param in character representation of the value
099         * @param offset offset of the first character to analyze
100         * @param len length of the array slice to analyze
101         */
102        public BigReal(char[] in, int offset, int len) {
103            d = new BigDecimal(in, offset, len);
104        }
105    
106        /** Build an instance from a characters representation.
107         * @param in character representation of the value
108         * @param offset offset of the first character to analyze
109         * @param len length of the array slice to analyze
110         * @param mc context to use
111         */
112        public BigReal(char[] in, int offset, int len, MathContext mc) {
113            d = new BigDecimal(in, offset, len, mc);
114        }
115    
116        /** Build an instance from a characters representation.
117         * @param in character representation of the value
118         * @param mc context to use
119         */
120        public BigReal(char[] in, MathContext mc) {
121            d = new BigDecimal(in, mc);
122        }
123    
124        /** Build an instance from a double.
125         * @param val value of the instance
126         */
127        public BigReal(double val) {
128            d = new BigDecimal(val);
129        }
130    
131        /** Build an instance from a double.
132         * @param val value of the instance
133         * @param mc context to use
134         */
135        public BigReal(double val, MathContext mc) {
136            d = new BigDecimal(val, mc);
137        }
138    
139        /** Build an instance from an int.
140         * @param val value of the instance
141         */
142        public BigReal(int val) {
143            d = new BigDecimal(val);
144        }
145    
146        /** Build an instance from an int.
147         * @param val value of the instance
148         * @param mc context to use
149         */
150        public BigReal(int val, MathContext mc) {
151            d = new BigDecimal(val, mc);
152        }
153    
154        /** Build an instance from a long.
155         * @param val value of the instance
156         */
157        public BigReal(long val) {
158            d = new BigDecimal(val);
159        }
160    
161        /** Build an instance from a long.
162         * @param val value of the instance
163         * @param mc context to use
164         */
165        public BigReal(long val, MathContext mc) {
166            d = new BigDecimal(val, mc);
167        }
168    
169        /** Build an instance from a String representation.
170         * @param val character representation of the value
171         */
172        public BigReal(String val) {
173            d = new BigDecimal(val);
174        }
175    
176        /** Build an instance from a String representation.
177         * @param val character representation of the value
178         * @param mc context to use
179         */
180        public BigReal(String val, MathContext mc)  {
181            d = new BigDecimal(val, mc);
182        }
183    
184        /** {@inheritDoc} */
185        public BigReal add(BigReal a) {
186            return new BigReal(d.add(a.d));
187        }
188    
189        /** {@inheritDoc} */
190        public BigReal subtract(BigReal a) {
191            return new BigReal(d.subtract(a.d));
192        }
193    
194        /** {@inheritDoc} */
195        public BigReal divide(BigReal a) throws ArithmeticException {
196            return new BigReal(d.divide(a.d));
197        }
198    
199        /** {@inheritDoc} */
200        public BigReal multiply(BigReal a) {
201            return new BigReal(d.multiply(a.d));
202        }
203    
204        /** {@inheritDoc} */
205        public int compareTo(BigReal a) {
206            return d.compareTo(a.d);
207        }
208    
209        /** Get the double value corresponding to the instance.
210         * @return double value corresponding to the instance
211         */
212        public double doubleValue() {
213            return d.doubleValue();
214        }
215    
216        /** Get the BigDecimal value corresponding to the instance.
217         * @return BigDecimal value corresponding to the instance
218         */
219        public BigDecimal bigDecimalValue() {
220            return d;
221        }
222    
223        /** {@inheritDoc} */
224        @Override
225        public boolean equals(Object other) {
226            try {
227                if (other == null) {
228                    return false;
229                }
230                return d.equals(((BigReal) other).d);
231            } catch (ClassCastException cce) {
232                return false;
233            }
234        }
235    
236        /** {@inheritDoc} */
237        @Override
238        public int hashCode() {
239            return d.hashCode();
240        }
241    
242        /** {@inheritDoc} */
243        public Field<BigReal> getField() {
244            return BigRealField.getInstance();
245        }
246    
247    }