Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 1.1 Source Code Directory
JDK 1.1 source code directory contains Java source code for JDK 1.1 core classes:
"C:\fyicenter\jdk-1.1.8\src".
Here is the list of Java classes of the JDK 1.1 source code:
✍: FYIcenter
⏎ java/math/BigDecimal.java
/* * @(#)BigDecimal.java 1.11 01/12/10 * * Copyright 2002 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.math; /** * Immutable, arbitrary-precision signed decimal numbers. A BigDecimal * consists of an arbitrary precision integer value and a non-negative * integer scale, which represents the number of decimal digits to the * right of the decimal point. (The number represented by the BigDecimal * is intVal/10**scale.) BigDecimals provide operations for basic arithmetic, * scale manipulation, comparison, format conversion and hashing. * * <p>The BigDecimal class gives its user complete control over rounding * behavior, forcing the user to explicitly specify a rounding behavior for * operations capable of discarding precision (divide and setScale). Eight * <em>rounding modes</em> are provided for this purpose. * * Two types of operations are provided for manipulating the scale of a * BigDecimal: scaling/rounding operations and decimal point motion operations. * Scaling/Rounding operations (SetScale) return a BigDecimal whose value is * approximately (or exactly) equal to that of the operand, but whose scale is * the specified value; that is, they increase or decrease the precision * of the number with minimal effect on its value. Decimal point motion * operations (movePointLeft and movePointRight) return a BigDecimal created * from the operand by moving the decimal point a specified distance in the * specified direction; that is, they change a number's value without affecting * its precision. * * @see BigInteger * @version 1.11, 01/12/10 * @author Josh Bloch */ public class BigDecimal extends Number { private BigInteger intVal; private int scale = 0; /* Appease the serialization gods */ private static final long serialVersionUID = 6108874887143696463L; // Constructors /** * Constructs a BigDecimal from a string containing an optional minus * sign followed by a sequence of zero or more decimal digits, optionally * followed by a fraction, which consists of a decimal point followed by * zero or more decimal digits. The string must contain at least one * digit in the integer or fractional part. The scale of the resulting * BigDecimal will be the number of digits to the right of the decimal * point in the string, or 0 if the string contains no decimal point. * The character-to-digit mapping is provided by Character.digit. * Any extraneous characters (including whitespace) will result in * a NumberFormatException. */ public BigDecimal(String val) throws NumberFormatException { int pointPos = val.indexOf('.'); if (pointPos == -1) { /* e.g. "123" */ intVal = new BigInteger(val); } else if (pointPos == val.length()-1) { /* e.g. "123." */ intVal = new BigInteger(val.substring(0, val.length()-1)); } else { /* Fraction part exists */ String fracString = val.substring(pointPos+1); scale = fracString.length(); BigInteger fraction = new BigInteger(fracString); if (fraction.signum() < 0) /* ".-123" illegal! */ throw new NumberFormatException(); if (pointPos==0) { /* e.g. ".123" */ intVal = fraction; } else if (val.charAt(0)=='-' && pointPos==1) { intVal = fraction.negate(); /* e.g. "-.123" */ } else { /* e.g. "-123.456" */ String intString = val.substring(0, pointPos); BigInteger intPart = new BigInteger(intString); if (val.charAt(0) == '-') fraction = fraction.negate(); intVal = timesTenToThe(intPart, scale).add(fraction); } } } /** * Translates a double into a BigDecimal. The scale of the BigDecimal * is the smallest value such that (10**scale * val) is an integer. * A double whose value is -infinity, +infinity or NaN will result in a * NumberFormatException. */ public BigDecimal(double val) throws NumberFormatException{ if (Double.isInfinite(val) || Double.isNaN(val)) throw new NumberFormatException("Infinite or NaN"); /* * Translate the double into sign, exponent and mantissa, according * to the formulae in JLS, Section 20.10.22. */ long valBits = Double.doubleToLongBits(val); int sign = ((valBits >> 63)==0 ? 1 : -1); int exponent = (int) ((valBits >> 52) & 0x7ffL); long mantissa = (exponent==0 ? (valBits & ((1L<<52) - 1)) << 1 : (valBits & ((1L<<52) - 1)) | (1L<<52)); exponent -= 1075; /* At this point, val == sign * mantissa * 2**exponent */ /* * Special case zero to to supress nonterminating normalization * and bogus scale calculation. */ if (mantissa == 0) { intVal = BigInteger.valueOf(0); return; } /* Normalize */ while((mantissa & 1) == 0) { /* i.e., Mantissa is even */ mantissa >>= 1; exponent++; } /* Calculate intVal and scale */ intVal = BigInteger.valueOf(sign*mantissa); if (exponent < 0) { intVal = intVal.multiply(BigInteger.valueOf(5).pow(-exponent)); scale = -exponent; } else if (exponent > 0) { intVal = intVal.multiply(BigInteger.valueOf(2).pow(exponent)); } } /** * Translates a BigInteger into a BigDecimal. The scale of the BigDecimal * is zero. */ public BigDecimal(BigInteger val) { intVal = val; } /** * Translates a BigInteger and a scale into a BigDecimal. The value * of the BigDecimal is (BigInteger/10**scale). A negative scale * will result in a NumberFormatException. */ public BigDecimal(BigInteger val, int scale) throws NumberFormatException { if (scale < 0) throw new NumberFormatException("Negative scale"); intVal = val; this.scale = scale; } // Static Factory Methods /** * Returns a BigDecimal with a value of (val/10**scale). This factory * is provided in preference to a (long) constructor because it allows * for reuse of frequently used BigDecimals (like 0 and 1), obviating * the need for exported constants. A negative scale will result in a * NumberFormatException. */ public static BigDecimal valueOf(long val, int scale) throws NumberFormatException { return new BigDecimal(BigInteger.valueOf(val), scale); } /** * Returns a BigDecimal with the given value and a scale of zero. * This factory is provided in preference to a (long) constructor * because it allows for reuse of frequently used BigDecimals (like * 0 and 1), obviating the need for exported constants. */ public static BigDecimal valueOf(long val) { return valueOf(val, 0); } // Arithmetic Operations /** * Returns a BigDecimal whose value is (this + val), and whose scale is * MAX(this.scale(), val.scale). */ public BigDecimal add(BigDecimal val){ BigDecimal arg[] = new BigDecimal[2]; arg[0] = this; arg[1] = val; matchScale(arg); return new BigDecimal(arg[0].intVal.add(arg[1].intVal), arg[0].scale); } /** * Returns a BigDecimal whose value is (this - val), and whose scale is * MAX(this.scale(), val.scale). */ public BigDecimal subtract(BigDecimal val){ BigDecimal arg[] = new BigDecimal[2]; arg[0] = this; arg[1] = val; matchScale(arg); return new BigDecimal(arg[0].intVal.subtract(arg[1].intVal), arg[0].scale); } /** * Returns a BigDecimal whose value is (this * val), and whose scale is * this.scale() + val.scale. */ public BigDecimal multiply(BigDecimal val){ return new BigDecimal(intVal.multiply(val.intVal), scale+val.scale); } /** * Returns a BigDecimal whose value is (this / val), and whose scale * is as specified. If rounding must be performed to generate a * result with the given scale, the specified rounding mode is * applied. Throws an ArithmeticException if val == 0, scale < 0, * or the rounding mode is ROUND_UNNECESSARY and the specified scale * is insufficient to represent the result of the division exactly. * Throws an IllegalArgumentException if roundingMode does not * represent a valid rounding mode. */ public BigDecimal divide(BigDecimal val, int scale, int roundingMode) throws ArithmeticException, IllegalArgumentException { if (scale < 0) throw new ArithmeticException("Negative scale"); if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY) throw new IllegalArgumentException("Invalid rounding mode"); /* * Rescale dividend or divisor (whichever can be "upscaled" to * produce correctly scaled quotient). */ BigDecimal dividend, divisor; if (scale + val.scale >= this.scale) { dividend = this.setScale(scale + val.scale); divisor = val; } else { dividend = this; divisor = val.setScale(this.scale - scale); } /* Do the division and return result if it's exact */ BigInteger i[] = dividend.intVal.divideAndRemainder(divisor.intVal); BigInteger q = i[0], r = i[1]; if (r.signum() == 0) return new BigDecimal(q, scale); else if (roundingMode == ROUND_UNNECESSARY) /* Rounding prohibited */ throw new ArithmeticException("Rounding necessary"); /* Round as appropriate */ int signum = dividend.signum() * divisor.signum(); /* Sign of result */ boolean increment; if (roundingMode == ROUND_UP) { /* Away from zero */ increment = true; } else if (roundingMode == ROUND_DOWN) { /* Towards zero */ increment = false; } else if (roundingMode == ROUND_CEILING) { /* Towards +infinity */ increment = (signum > 0); } else if (roundingMode == ROUND_FLOOR) { /* Towards -infinity */ increment = (signum < 0); } else { /* Remaining modes based on nearest-neighbor determination */ int cmpFracHalf = r.abs().multiply(BigInteger.valueOf(2)). compareTo(divisor.intVal.abs()); if (cmpFracHalf < 0) { /* We're closer to higher digit */ increment = false; } else if (cmpFracHalf > 0) { /* We're closer to lower digit */ increment = true; } else { /* We're dead-center */ if (roundingMode == ROUND_HALF_UP) increment = true; else if (roundingMode == ROUND_HALF_DOWN) increment = false; else /* roundingMode == ROUND_HALF_EVEN */ increment = q.testBit(0); /* true iff q is odd */ } } return (increment ? new BigDecimal(q.add(BigInteger.valueOf(signum)), scale) : new BigDecimal(q, scale)); } /** * Returns a BigDecimal whose value is (this / val), and whose scale * is this.scale(). If rounding must be performed to generate a * result with the given scale, the specified rounding mode is * applied. Throws an ArithmeticException if val == 0. Throws * an IllegalArgumentException if roundingMode does not represent a * valid rounding mode. */ public BigDecimal divide(BigDecimal val, int roundingMode) throws ArithmeticException, IllegalArgumentException{ return this.divide(val, scale, roundingMode); } /** * Returns a BigDecimal whose value is the absolute value of this * number, and whose scale is this.scale(). */ public BigDecimal abs(){ return (signum() < 0 ? negate() : this); } /** * Returns a BigDecimal whose value is -1 * this, and whose scale is * this.scale(). */ public BigDecimal negate(){ return new BigDecimal(intVal.negate(), scale); } /** * Returns the signum function of this number (i.e., -1, 0 or 1 as * the value of this number is negative, zero or positive). */ public int signum(){ return intVal.signum(); } /** * Returns the scale of this number. */ public int scale(){ return scale; } // Rounding Modes /** * Always increment the digit prior to a non-zero discarded fraction. * Note that this rounding mode never decreases the magnitude. * (Rounds away from zero.) */ public final static int ROUND_UP = 0; /** * Never increment the digit prior to a discarded fraction (i.e., * truncate). Note that this rounding mode never increases the magnitude. * (Rounds towards zero.) */ public final static int ROUND_DOWN = 1; /** * If the BigDecimal is positive, behave as for ROUND_UP; if negative, * behave as for ROUND_DOWN. Note that this rounding mode never decreases * the value. (Rounds towards positive infinity.) */ public final static int ROUND_CEILING = 2; /** * If the BigDecimal is positive, behave as for ROUND_DOWN; if negative * behave as for ROUND_UP. Note that this rounding mode never increases * the value. (Rounds towards negative infinity.) */ public final static int ROUND_FLOOR = 3; /** * Behave as for ROUND_UP if the discarded fraction is >= .5; otherwise, * behave as for ROUND_DOWN. (Rounds towards "nearest neighbor" unless * both neighbors are equidistant, in which case rounds up.) */ public final static int ROUND_HALF_UP = 4; /** * Behave as for ROUND_UP if the discarded fraction is > .5; otherwise, * behave as for ROUND_DOWN. (Rounds towards "nearest neighbor" unless * both neighbors are equidistant, in which case rounds down.) */ public final static int ROUND_HALF_DOWN = 5; /** * Behave as for ROUND_HALF_UP if the digit to the left of the discarded * fraction is odd; behave as for ROUND_HALF_DOWN if it's even. (Rounds * towards the "nearest neighbor" unless both neighbors are equidistant, * in which case, rounds towards the even neighbor.) */ public final static int ROUND_HALF_EVEN = 6; /** * This "pseudo-rounding-mode" is actually an assertion that the requested * operation has an exact result, hence no rounding is necessary. If this * rounding mode is specified on an operation that yields an inexact result, * an arithmetic exception is thrown. */ public final static int ROUND_UNNECESSARY = 7; // Scaling/Rounding Operations /** * Returns a BigDecimal whose scale is the specified value, and whose * integer value is determined by multiplying or dividing this BigDecimal's * integer value by the appropriate power of ten to maintain the overall * value. If the scale is reduced by the operation, the integer value * must be divided (rather than multiplied), and precision may be lost; * in this case, the specified rounding mode is applied to the division. * Throws an ArithmeticException if scale is negative, or the rounding * mode is ROUND_UNNECESSARY and it is impossible to perform the * specified scaling operation without loss of precision. Throws an * IllegalArgumentException if roundingMode does not represent a valid * rounding mode. */ public BigDecimal setScale(int scale, int roundingMode) throws ArithmeticException, IllegalArgumentException { if (scale < 0) throw new ArithmeticException("Negative scale"); if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY) throw new IllegalArgumentException("Invalid rounding mode"); /* Handle the easy cases */ if (scale == this.scale) return this; else if (scale > this.scale) return new BigDecimal(timesTenToThe(intVal, scale-this.scale), scale); else /* scale < this.scale */ return divide(valueOf(1), scale, roundingMode); } /** * Returns a BigDecimal whose scale is the specified value, and whose * value is exactly equal to this number's. Throws an ArithmeticException * if this is not possible. This call is typically used to increase * the scale, in which case it is guaranteed that there exists a BigDecimal * of the specified scale and the correct value. The call can also be used * to reduce the scale if the caller knows that the number has sufficiently * many zeros at the end of its fractional part (i.e., factors of ten in * its integer value) to allow for the rescaling without loss of precision. * Note that this call returns the same result as the two argument version * of setScale, but saves the caller the trouble of specifying a rounding * mode in cases where it is irrelevant. */ public BigDecimal setScale(int scale) throws ArithmeticException, IllegalArgumentException { return setScale(scale, ROUND_UNNECESSARY); } // Decimal Point Motion Operations /** * Returns a BigDecimal which is equivalent to this one with the decimal * point moved n places to the left. If n is non-negative, the call merely * adds n to the scale. If n is negative, the call is equivalent to * movePointRight(-n). (The BigDecimal returned by this call has value * (this * 10**-n) and scale MAX(this.scale()+n, 0).) */ public BigDecimal movePointLeft(int n){ return (n>=0 ? new BigDecimal(intVal, scale+n) : movePointRight(-n)); } /** * Moves the decimal point the specified number of places to the right. * If this number's scale is >= n, the call merely subtracts n from the * scale; otherwise, it sets the scale to zero, and multiplies the integer * value by 10 ** (n - this.scale). If n is negative, the call is * equivalent to movePointLeft(-n). (The BigDecimal returned by this call * has value (this * 10**n) and scale MAX(this.scale()-n, 0).) */ public BigDecimal movePointRight(int n){ return (scale >= n ? new BigDecimal(intVal, scale-n) : new BigDecimal(timesTenToThe(intVal, n-scale),0)); } // Comparison Operations /** * Returns -1, 0 or 1 as this number is less than, equal to, or greater * than val. Two BigDecimals that are equal in value but have a * different scale (e.g., 2.0, 2.00) are considered equal by this method. * This method is provided in preference to individual methods for each * of the six boolean comparison operators (<, ==, >, >=, !=, <=). The * suggested idiom for performing these comparisons is: (x.compareTo(y) * <op> 0), where <op> is one of the six comparison operators. */ public int compareTo(BigDecimal val){ /* Optimization: would run fine without the next three lines */ int sigDiff = signum() - val.signum(); if (sigDiff != 0) return (sigDiff > 0 ? 1 : -1); /* If signs match, scale and compare intVals */ BigDecimal arg[] = new BigDecimal[2]; arg[0] = this; arg[1] = val; matchScale(arg); return arg[0].intVal.compareTo(arg[1].intVal); } /** * Returns true iff x is a BigDecimal whose value is equal to this number. * This method is provided so that BigDecimals can be used as hash keys. * Unlike compareTo, this method considers two BigDecimals equal only * if they are equal in value and scale. */ public boolean equals(Object x){ if (!(x instanceof BigDecimal)) return false; BigDecimal xDec = (BigDecimal) x; return scale == xDec.scale && intVal.equals(xDec.intVal); } /** * Returns the BigDecimal whose value is the lesser of this and val. * If the values are equal (as defined by the compareTo operator), * either may be returned. */ public BigDecimal min(BigDecimal val){ return (compareTo(val)<0 ? this : val); } /** * Returns the BigDecimal whose value is the greater of this and val. * If the values are equal (as defined by the compareTo operator), * either may be returned. */ public BigDecimal max(BigDecimal val){ return (compareTo(val)>0 ? this : val); } // Hash Function /** * Computes a hash code for this object. Note that two BigDecimals * that are numerically equal but differ in scale (e.g., 2.0, 2.00) will * not generally have the same hash code. */ public int hashCode(){ return 37*intVal.hashCode() + scale; } // Format Converters /** * Returns the string representation of this number. The digit-to- * character mapping provided by Character.forDigit is used. The minus * sign and decimal point are used to indicate sign and scale. (This * representation is compatible with the (String, int) constructor.) */ public String toString(){ if (scale == 0) /* No decimal point */ return intVal.toString(); /* Insert decimal point */ StringBuffer buf; String intString = intVal.abs().toString(); int signum = signum(); int insertionPoint = intString.length() - scale; if (insertionPoint == 0) { /* Point goes right before intVal */ return (signum<0 ? "-0." : "0.") + intString; } else if (insertionPoint > 0) { /* Point goes inside intVal */ buf = new StringBuffer(intString); buf.insert(insertionPoint, '.'); if (signum < 0) buf.insert(0, '-'); } else { /* We must insert zeros between point and intVal */ buf = new StringBuffer(3-insertionPoint + intString.length()); buf.append(signum<0 ? "-0." : "0."); for (int i=0; i<-insertionPoint; i++) buf.append('0'); buf.append(intString); } return buf.toString(); } /** * Converts this number to a BigInteger. Standard narrowing primitive * conversion as per The Java Language Specification. In particular, * note that any fractional part of this number will be truncated. */ public BigInteger toBigInteger(){ return (scale==0 ? intVal : intVal.divide(BigInteger.valueOf(10).pow(scale))); } /** * Converts this number to an int. Standard narrowing primitive conversion * as per The Java Language Specification. In particular, note that any * fractional part of this number will be truncated. */ public int intValue(){ return toBigInteger().intValue(); } /** * Converts this number to a long. Standard narrowing primitive conversion * as per The Java Language Specification. In particular, note that any * fractional part of this number will be truncated. */ public long longValue(){ return toBigInteger().longValue(); } /** * Converts this number to a float. Similar to the double-to-float * narrowing primitive conversion defined in The Java Language * Specification: if the number has too great a magnitude to represent * as a float, it will be converted to infinity or negative infinity, * as appropriate. */ public float floatValue(){ /* Somewhat inefficient, but guaranteed to work. */ return Float.valueOf(this.toString()).floatValue(); } /** * Converts the number to a double. Similar to the double-to-float * narrowing primitive conversion defined in The Java Language * Specification: if the number has too great a magnitude to represent * as a double, it will be converted to infinity or negative infinity, * as appropriate. */ public double doubleValue(){ /* Somewhat inefficient, but guaranteed to work. */ return Double.valueOf(this.toString()).doubleValue(); } // Private "Helper" Methods /* Returns (a * 10^b) */ private static BigInteger timesTenToThe(BigInteger a, int b) { return a.multiply(BigInteger.valueOf(10).pow(b)); } /* * If the scales of val[0] and val[1] differ, rescale (non-destructively) * the lower-scaled BigDecimal so they match. */ private static void matchScale(BigDecimal[] val) { if (val[0].scale < val[1].scale) val[0] = val[0].setScale(val[1].scale); else if (val[1].scale < val[0].scale) val[1] = val[1].setScale(val[0].scale); } /** * Reconstitute the <tt>BigDecimal</tt> instance from a stream (that is, * deserialize it). */ private synchronized void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in all fields s.defaultReadObject(); // Validate scale factor if (scale < 0) throw new java.io.StreamCorruptedException( "BigDecimal: Negative scale"); } }
⏎ java/math/BigDecimal.java
Or download all of them as a single archive file:
File name: jdk-1.1.8-src.zip File size: 1574187 bytes Release date: 2018-11-16 Download
⇒ Backup JDK 1.1 Installation Directory
2018-11-17, 176930👍, 0💬
Popular Posts:
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-s...
JDK 11 java.compiler.jmod is the JMOD file for JDK 11 Compiler module. JDK 11 Compiler module compil...
What Is HttpComponents commons-httpclient-3.1.j ar?HttpComponents commons-httpclient-3.1.j aris the ...
What Is javamail1_1_3.zip? javamail1_1_3.zip is the binary package of JavaMail API 1.1.3 in ZIP form...
JDK 11 jdk.xml.dom.jmod is the JMOD file for JDK 11 XML DOM module. JDK 11 XML DOM module compiled c...