1 /* 2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.misc; 27 28 import java.util.Arrays; 29 30 public class FormattedFloatingDecimal{ 31 32 public enum Form { SCIENTIFIC, COMPATIBLE, DECIMAL_FLOAT, GENERAL }; 33 34 35 public static FormattedFloatingDecimal valueOf(double d, int precision, Form form){ 36 FloatingDecimal.BinaryToASCIIConverter fdConverter = 37 FloatingDecimal.getBinaryToASCIIConverter(d, form == Form.COMPATIBLE); 38 return new FormattedFloatingDecimal(precision,form, fdConverter); 39 } 40 41 private int decExponentRounded; 42 private char[] mantissa; 43 private char[] exponent; 44 45 private static final ThreadLocal<Object> threadLocalCharBuffer = 46 new ThreadLocal<Object>() { 47 @Override 48 protected Object initialValue() { 49 return new char[20]; 50 } 51 }; 52 53 private static char[] getBuffer(){ 54 return (char[]) threadLocalCharBuffer.get(); 55 } 56 57 private FormattedFloatingDecimal(int precision, Form form, FloatingDecimal.BinaryToASCIIConverter fdConverter) { 58 if (fdConverter.isExceptional()) { 59 this.mantissa = fdConverter.toJavaFormatString().toCharArray(); 60 this.exponent = null; 61 return; 62 } 63 char[] digits = getBuffer(); 64 int nDigits = fdConverter.getDigits(digits); 65 int decExp = fdConverter.getDecimalExponent(); 66 int exp; 67 boolean isNegative = fdConverter.isNegative(); 68 switch (form) { 69 case COMPATIBLE: 70 exp = decExp; 71 this.decExponentRounded = exp; 72 fillCompatible(precision, digits, nDigits, exp, isNegative); 73 break; 74 case DECIMAL_FLOAT: 75 exp = applyPrecision(decExp, digits, nDigits, decExp + precision); 76 fillDecimal(precision, digits, nDigits, exp, isNegative); 77 this.decExponentRounded = exp; 78 break; 79 case SCIENTIFIC: 80 exp = applyPrecision(decExp, digits, nDigits, precision + 1); 81 fillScientific(precision, digits, nDigits, exp, isNegative); 82 this.decExponentRounded = exp; 83 break; 84 case GENERAL: 85 exp = applyPrecision(decExp, digits, nDigits, precision); 86 // adjust precision to be the number of digits to right of decimal 87 // the real exponent to be output is actually exp - 1, not exp 88 if (exp - 1 < -4 || exp - 1 >= precision) { 89 // form = Form.SCIENTIFIC; 90 precision--; 91 fillScientific(precision, digits, nDigits, exp, isNegative); 92 } else { 93 // form = Form.DECIMAL_FLOAT; 94 precision = precision - exp; 95 fillDecimal(precision, digits, nDigits, exp, isNegative); 96 } 97 this.decExponentRounded = exp; 98 break; 99 default: 100 assert false; 101 } 102 } 103 104 // returns the exponent after rounding has been done by applyPrecision 105 public int getExponentRounded() { 106 return decExponentRounded - 1; 107 } 108 109 public char[] getMantissa(){ 110 return mantissa; 111 } 112 113 public char[] getExponent(){ 114 return exponent; 115 } 116 117 /** 118 * Returns new decExp in case of overflow. 119 */ 120 private static int applyPrecision(int decExp, char[] digits, int nDigits, int prec) { 121 if (prec >= nDigits || prec < 0) { 122 // no rounding necessary 123 return decExp; 124 } 125 if (prec == 0) { 126 // only one digit (0 or 1) is returned because the precision 127 // excludes all significant digits 128 if (digits[0] >= '5') { 129 digits[0] = '1'; 130 Arrays.fill(digits, 1, nDigits, '0'); 131 return decExp + 1; 132 } else { 133 Arrays.fill(digits, 0, nDigits, '0'); 134 return decExp; 135 } 136 } 137 int q = digits[prec]; 138 if (q >= '5') { 139 int i = prec; 140 q = digits[--i]; 141 if ( q == '9' ) { 142 while ( q == '9' && i > 0 ){ 143 q = digits[--i]; 144 } 145 if ( q == '9' ){ 146 // carryout! High-order 1, rest 0s, larger exp. 147 digits[0] = '1'; 148 Arrays.fill(digits, 1, nDigits, '0'); 149 return decExp+1; 150 } 151 } 152 digits[i] = (char)(q + 1); 153 Arrays.fill(digits, i+1, nDigits, '0'); 154 } else { 155 Arrays.fill(digits, prec, nDigits, '0'); 156 } 157 return decExp; 158 } 159 160 /** 161 * Fills mantissa and exponent char arrays for compatible format. 162 */ 163 private void fillCompatible(int precision, char[] digits, int nDigits, int exp, boolean isNegative) { 164 int startIndex = isNegative ? 1 : 0; 165 if (exp > 0 && exp < 8) { 166 // print digits.digits. 167 if (nDigits < exp) { 168 int extraZeros = exp - nDigits; 169 mantissa = create(isNegative, nDigits + extraZeros + 2); 170 System.arraycopy(digits, 0, mantissa, startIndex, nDigits); 171 Arrays.fill(mantissa, startIndex + nDigits, startIndex + nDigits + extraZeros, '0'); 172 mantissa[startIndex + nDigits + extraZeros] = '.'; 173 mantissa[startIndex + nDigits + extraZeros+1] = '0'; 174 } else if (exp < nDigits) { 175 int t = Math.min(nDigits - exp, precision); 176 mantissa = create(isNegative, exp + 1 + t); 177 System.arraycopy(digits, 0, mantissa, startIndex, exp); 178 mantissa[startIndex + exp ] = '.'; 179 System.arraycopy(digits, exp, mantissa, startIndex+exp+1, t); 180 } else { // exp == digits.length 181 mantissa = create(isNegative, nDigits + 2); 182 System.arraycopy(digits, 0, mantissa, startIndex, nDigits); 183 mantissa[startIndex + nDigits ] = '.'; 184 mantissa[startIndex + nDigits +1] = '0'; 185 } 186 } else if (exp <= 0 && exp > -3) { 187 int zeros = Math.max(0, Math.min(-exp, precision)); 188 int t = Math.max(0, Math.min(nDigits, precision + exp)); 189 // write '0' s before the significant digits 190 if (zeros > 0) { 191 mantissa = create(isNegative, zeros + 2 + t); 192 mantissa[startIndex] = '0'; 193 mantissa[startIndex+1] = '.'; 194 Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0'); 195 if (t > 0) { 196 // copy only when significant digits are within the precision 197 System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t); 198 } 199 } else if (t > 0) { 200 mantissa = create(isNegative, zeros + 2 + t); 201 mantissa[startIndex] = '0'; 202 mantissa[startIndex + 1] = '.'; 203 // copy only when significant digits are within the precision 204 System.arraycopy(digits, 0, mantissa, startIndex + 2, t); 205 } else { 206 this.mantissa = create(isNegative, 1); 207 this.mantissa[startIndex] = '0'; 208 } 209 } else { 210 if (nDigits > 1) { 211 mantissa = create(isNegative, nDigits + 1); 212 mantissa[startIndex] = digits[0]; 213 mantissa[startIndex + 1] = '.'; 214 System.arraycopy(digits, 1, mantissa, startIndex + 2, nDigits - 1); 215 } else { 216 mantissa = create(isNegative, 3); 217 mantissa[startIndex] = digits[0]; 218 mantissa[startIndex + 1] = '.'; 219 mantissa[startIndex + 2] = '0'; 220 } 221 int e, expStartIntex; 222 boolean isNegExp = (exp <= 0); 223 if (isNegExp) { 224 e = -exp + 1; 225 expStartIntex = 1; 226 } else { 227 e = exp - 1; 228 expStartIntex = 0; 229 } 230 // decExponent has 1, 2, or 3, digits 231 if (e <= 9) { 232 exponent = create(isNegExp,1); 233 exponent[expStartIntex] = (char) (e + '0'); 234 } else if (e <= 99) { 235 exponent = create(isNegExp,2); 236 exponent[expStartIntex] = (char) (e / 10 + '0'); 237 exponent[expStartIntex+1] = (char) (e % 10 + '0'); 238 } else { 239 exponent = create(isNegExp,3); 240 exponent[expStartIntex] = (char) (e / 100 + '0'); 241 e %= 100; 242 exponent[expStartIntex+1] = (char) (e / 10 + '0'); 243 exponent[expStartIntex+2] = (char) (e % 10 + '0'); 244 } 245 } 246 } 247 248 private static char[] create(boolean isNegative, int size) { 249 if(isNegative) { 250 char[] r = new char[size +1]; 251 r[0] = '-'; 252 return r; 253 } else { 254 return new char[size]; 255 } 256 } 257 258 /* 259 * Fills mantissa char arrays for DECIMAL_FLOAT format. 260 * Exponent should be equal to null. 261 */ 262 private void fillDecimal(int precision, char[] digits, int nDigits, int exp, boolean isNegative) { 263 int startIndex = isNegative ? 1 : 0; 264 if (exp > 0) { 265 // print digits.digits. 266 if (nDigits < exp) { 267 mantissa = create(isNegative,exp); 268 System.arraycopy(digits, 0, mantissa, startIndex, nDigits); 269 Arrays.fill(mantissa, startIndex + nDigits, startIndex + exp, '0'); 270 // Do not append ".0" for formatted floats since the user 271 // may request that it be omitted. It is added as necessary 272 // by the Formatter. 273 } else { 274 int t = Math.min(nDigits - exp, precision); 275 mantissa = create(isNegative, exp + (t > 0 ? (t + 1) : 0)); 276 System.arraycopy(digits, 0, mantissa, startIndex, exp); 277 // Do not append ".0" for formatted floats since the user 278 // may request that it be omitted. It is added as necessary 279 // by the Formatter. 280 if (t > 0) { 281 mantissa[startIndex + exp] = '.'; 282 System.arraycopy(digits, exp, mantissa, startIndex + exp + 1, t); 283 } 284 } 285 } else if (exp <= 0) { 286 int zeros = Math.max(0, Math.min(-exp, precision)); 287 int t = Math.max(0, Math.min(nDigits, precision + exp)); 288 // write '0' s before the significant digits 289 if (zeros > 0) { 290 mantissa = create(isNegative, zeros + 2 + t); 291 mantissa[startIndex] = '0'; 292 mantissa[startIndex+1] = '.'; 293 Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0'); 294 if (t > 0) { 295 // copy only when significant digits are within the precision 296 System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t); 297 } 298 } else if (t > 0) { 299 mantissa = create(isNegative, zeros + 2 + t); 300 mantissa[startIndex] = '0'; 301 mantissa[startIndex + 1] = '.'; 302 // copy only when significant digits are within the precision 303 System.arraycopy(digits, 0, mantissa, startIndex + 2, t); 304 } else { 305 this.mantissa = create(isNegative, 1); 306 this.mantissa[startIndex] = '0'; 307 } 308 } 309 } 310 311 /** 312 * Fills mantissa and exponent char arrays for SCIENTIFIC format. 313 */ 314 private void fillScientific(int precision, char[] digits, int nDigits, int exp, boolean isNegative) { 315 int startIndex = isNegative ? 1 : 0; 316 int t = Math.max(0, Math.min(nDigits - 1, precision)); 317 if (t > 0) { 318 mantissa = create(isNegative, t + 2); 319 mantissa[startIndex] = digits[0]; 320 mantissa[startIndex + 1] = '.'; 321 System.arraycopy(digits, 1, mantissa, startIndex + 2, t); 322 } else { 323 mantissa = create(isNegative, 1); 324 mantissa[startIndex] = digits[0]; 325 } 326 char expSign; 327 int e; 328 if (exp <= 0) { 329 expSign = '-'; 330 e = -exp + 1; 331 } else { 332 expSign = '+' ; 333 e = exp - 1; 334 } 335 // decExponent has 1, 2, or 3, digits 336 if (e <= 9) { 337 exponent = new char[] { expSign, 338 '0', (char) (e + '0') }; 339 } else if (e <= 99) { 340 exponent = new char[] { expSign, 341 (char) (e / 10 + '0'), (char) (e % 10 + '0') }; 342 } else { 343 char hiExpChar = (char) (e / 100 + '0'); 344 e %= 100; 345 exponent = new char[] { expSign, 346 hiExpChar, (char) (e / 10 + '0'), (char) (e % 10 + '0') }; 347 } 348 } 349 } 350
