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.math3.util; 018 019 import org.apache.commons.math3.Field; 020 import org.apache.commons.math3.FieldElement; 021 022 /** 023 * This class wraps a {@code double} value in an object. It is similar to the 024 * standard class {@link Double}, while also implementing the 025 * {@link FieldElement} interface. 026 * 027 * @since 3.1 028 * @version $Id: Decimal64.java 1306177 2012-03-28 05:40:46Z celestin $ 029 */ 030 public class Decimal64 extends Number implements FieldElement<Decimal64>, 031 Comparable<Decimal64> { 032 033 /** The constant value of {@code 0d} as a {@code Decimal64}. */ 034 public static final Decimal64 ZERO; 035 036 /** The constant value of {@code 1d} as a {@code Decimal64}. */ 037 public static final Decimal64 ONE; 038 039 /** 040 * The constant value of {@link Double#NEGATIVE_INFINITY} as a 041 * {@code Decimal64}. 042 */ 043 public static final Decimal64 NEGATIVE_INFINITY; 044 045 /** 046 * The constant value of {@link Double#POSITIVE_INFINITY} as a 047 * {@code Decimal64}. 048 */ 049 public static final Decimal64 POSITIVE_INFINITY; 050 051 /** The constant value of {@link Double#NaN} as a {@code Decimal64}. */ 052 public static final Decimal64 NAN; 053 054 /** */ 055 private static final long serialVersionUID = 20120227L; 056 057 static { 058 ZERO = new Decimal64(0d); 059 ONE = new Decimal64(1d); 060 NEGATIVE_INFINITY = new Decimal64(Double.NEGATIVE_INFINITY); 061 POSITIVE_INFINITY = new Decimal64(Double.POSITIVE_INFINITY); 062 NAN = new Decimal64(Double.NaN); 063 } 064 065 /** The primitive {@code double} value of this object. */ 066 private final double value; 067 068 /** 069 * Creates a new instance of this class. 070 * 071 * @param x the primitive {@code double} value of the object to be created 072 */ 073 public Decimal64(final double x) { 074 this.value = x; 075 } 076 077 /* 078 * Methods from the FieldElement interface. 079 */ 080 081 /** {@inheritDoc} */ 082 public Field<Decimal64> getField() { 083 return Decimal64Field.getInstance(); 084 } 085 086 /** 087 * {@inheritDoc} 088 * 089 * The current implementation strictly enforces 090 * {@code this.add(a).equals(new Decimal64(this.doubleValue() 091 * + a.doubleValue()))}. 092 */ 093 public Decimal64 add(final Decimal64 a) { 094 return new Decimal64(this.value + a.value); 095 } 096 097 /** 098 * {@inheritDoc} 099 * 100 * The current implementation strictly enforces 101 * {@code this.subtract(a).equals(new Decimal64(this.doubleValue() 102 * - a.doubleValue()))}. 103 */ 104 public Decimal64 subtract(final Decimal64 a) { 105 return new Decimal64(this.value - a.value); 106 } 107 108 /** 109 * {@inheritDoc} 110 * 111 * The current implementation strictly enforces 112 * {@code this.negate().equals(new Decimal64(-this.doubleValue()))}. 113 */ 114 public Decimal64 negate() { 115 return new Decimal64(-this.value); 116 } 117 118 /** 119 * {@inheritDoc} 120 * 121 * The current implementation strictly enforces 122 * {@code this.multiply(a).equals(new Decimal64(this.doubleValue() 123 * * a.doubleValue()))}. 124 */ 125 public Decimal64 multiply(final Decimal64 a) { 126 return new Decimal64(this.value * a.value); 127 } 128 129 /** 130 * {@inheritDoc} 131 * 132 * The current implementation strictly enforces 133 * {@code this.multiply(n).equals(new Decimal64(n * this.doubleValue()))}. 134 */ 135 public Decimal64 multiply(final int n) { 136 return new Decimal64(n * this.value); 137 } 138 139 /** 140 * {@inheritDoc} 141 * 142 * The current implementation strictly enforces 143 * {@code this.divide(a).equals(new Decimal64(this.doubleValue() 144 * / a.doubleValue()))}. 145 * 146 */ 147 public Decimal64 divide(final Decimal64 a) { 148 return new Decimal64(this.value / a.value); 149 } 150 151 /** 152 * {@inheritDoc} 153 * 154 * The current implementation strictly enforces 155 * {@code this.reciprocal().equals(new Decimal64(1.0 156 * / this.doubleValue()))}. 157 */ 158 public Decimal64 reciprocal() { 159 return new Decimal64(1.0 / this.value); 160 } 161 162 /* 163 * Methods from the Number abstract class 164 */ 165 166 /** 167 * {@inheritDoc} 168 * 169 * The current implementation performs casting to a {@code byte}. 170 */ 171 @Override 172 public byte byteValue() { 173 return (byte) value; 174 } 175 176 /** 177 * {@inheritDoc} 178 * 179 * The current implementation performs casting to a {@code short}. 180 */ 181 @Override 182 public short shortValue() { 183 return (short) value; 184 } 185 186 /** 187 * {@inheritDoc} 188 * 189 * The current implementation performs casting to a {@code int}. 190 */ 191 @Override 192 public int intValue() { 193 return (int) value; 194 } 195 196 /** 197 * {@inheritDoc} 198 * 199 * The current implementation performs casting to a {@code long}. 200 */ 201 @Override 202 public long longValue() { 203 return (long) value; 204 } 205 206 /** 207 * {@inheritDoc} 208 * 209 * The current implementation performs casting to a {@code float}. 210 */ 211 @Override 212 public float floatValue() { 213 return (float) value; 214 } 215 216 /** {@inheritDoc} */ 217 @Override 218 public double doubleValue() { 219 return value; 220 } 221 222 /* 223 * Methods from the Comparable interface. 224 */ 225 226 /** 227 * {@inheritDoc} 228 * 229 * The current implementation returns the same value as 230 * <center> {@code new Double(this.doubleValue()).compareTo(new 231 * Double(o.doubleValue()))} </center> 232 * 233 * @see Double#compareTo(Double) 234 */ 235 public int compareTo(final Decimal64 o) { 236 return Double.compare(this.value, o.value); 237 } 238 239 /* 240 * Methods from the Object abstract class. 241 */ 242 243 /** {@inheritDoc} */ 244 @Override 245 public boolean equals(final Object obj) { 246 if (obj instanceof Decimal64) { 247 final Decimal64 that = (Decimal64) obj; 248 return Double.doubleToLongBits(this.value) == Double 249 .doubleToLongBits(that.value); 250 } 251 return false; 252 } 253 254 /** 255 * {@inheritDoc} 256 * 257 * The current implementation returns the same value as 258 * {@code new Double(this.doubleValue()).hashCode()} 259 * 260 * @see Double#hashCode() 261 */ 262 @Override 263 public int hashCode() { 264 long v = Double.doubleToLongBits(value); 265 return (int) (v ^ (v >>> 32)); 266 } 267 268 /** 269 * {@inheritDoc} 270 * 271 * The returned {@code String} is equal to 272 * {@code Double.toString(this.doubleValue())} 273 * 274 * @see Double#toString(double) 275 */ 276 @Override 277 public String toString() { 278 return Double.toString(value); 279 } 280 281 /* 282 * Methods inspired by the Double class. 283 */ 284 285 /** 286 * Returns {@code true} if {@code this} double precision number is infinite 287 * ({@link Double#POSITIVE_INFINITY} or {@link Double#NEGATIVE_INFINITY}). 288 * 289 * @return {@code true} if {@code this} number is infinite 290 */ 291 public boolean isInfinite() { 292 return Double.isInfinite(value); 293 } 294 295 /** 296 * Returns {@code true} if {@code this} double precision number is 297 * Not-a-Number ({@code NaN}), false otherwise. 298 * 299 * @return {@code true} if {@code this} is {@code NaN} 300 */ 301 public boolean isNaN() { 302 return Double.isNaN(value); 303 } 304 }