Examples of com.ibm.icu.math.BigDecimal

com.ibm.icu.math.BigDecimal
hursley.ibm.com/decimal
[This URL will change.]
Operator methods

Operations on BigDecimal numbers are controlled by a {@link MathContext} object, which provides the context (precision andother information) for the operation. Methods that can take a MathContext parameter implement the standard arithmetic operators for BigDecimal objects and are known as operator methods. The default settings provided by the constant {@link MathContext#DEFAULT} (digits=9,form=SCIENTIFIC, lostDigits=false, roundingMode=ROUND_HALF_UP) perform general-purpose floating point arithmetic to nine digits of precision. The MathContext parameter must not be null.
Each operator method also has a version provided which does not take a MathContext parameter. For this version of each method, the context settings used are digits=0, form=PLAIN, lostDigits=false, roundingMode=ROUND_HALF_UP; these settings perform fixed point arithmetic with unlimited precision, as defined for the original BigDecimal class in Java 1.1 and Java 1.2.
For monadic operators, only the optional MathContext parameter is present; the operation acts upon the current object.
For dyadic operators, a BigDecimal parameter is always present; it must not be null. The operation acts with the current object being the left-hand operand and the BigDecimal parameter being the right-hand operand.
For example, adding two BigDecimal objects referred to by the names award and extra could be written as any of:
award.add(extra) award.add(extra, MathContext.DEFAULT) award.add(extra, acontext)
(where acontext is a MathContext object), which would return a BigDecimal object whose value is the result of adding award and extra under the appropriate context settings.
When a BigDecimal operator method is used, a set of rules define what the result will be (and, by implication, how the result would be represented as a character string). These rules are defined in the BigDecimal arithmetic documentation (see the URL above), but in summary:
- Results are normally calculated with up to some maximum number of significant digits. For example, if the MathContext parameter for an operation were MathContext.DEFAULT then the result would be rounded to 9 digits; the division of 2 by 3 would then result in 0.666666667.
  You can change the default of 9 significant digits by providing the method with a suitable MathContext object. This lets you calculate using as many digits as you need -- thousands, if necessary. Fixed point (scaled) arithmetic is indicated by using a digits setting of 0 (or omitting the MathContext parameter).
  Similarly, you can change the algorithm used for rounding from the default "classic" algorithm.
- In standard arithmetic (that is, when the form setting is not PLAIN), a zero result is always expressed as the single digit '0' (that is, with no sign, decimal point, or exponent part).
- Except for the division and power operators in standard arithmetic, trailing zeros are preserved (this is in contrast to binary floating point operations and most electronic calculators, which lose the information about trailing zeros in the fractional part of results).
  So, for example:
  new BigDecimal("2.40").add( new BigDecimal("2")) => "4.40" new BigDecimal("2.40").subtract(new BigDecimal("2")) => "0.40" new BigDecimal("2.40").multiply(new BigDecimal("2")) => "4.80" new BigDecimal("2.40").divide( new BigDecimal("2"), def) => "1.2"
  where the value on the right of the => would be the result of the operation, expressed as a String, and def (in this and following examples) refers to MathContext.DEFAULT). This preservation of trailing zeros is desirable for most calculations (including financial calculations). If necessary, trailing zeros may be easily removed using division by 1.
- In standard arithmetic, exponential form is used for a result depending on its value and the current setting of digits (the default is 9 digits). If the number of places needed before the decimal point exceeds the digits setting, or the absolute value of the number is less than 0.000001, then the number will be expressed in exponential notation; thus
  new BigDecimal("1e+6").multiply(new BigDecimal("1e+6"), def)
  results in 1E+12 instead of 1000000000000, and
  new BigDecimal("1").divide(new BigDecimal("3E+10"), def)
  results in 3.33333333E-11 instead of 0.0000000000333333333.
  The form of the exponential notation (scientific or engineering) is determined by the form setting.
  The names of methods in this class follow the conventions established by java.lang.Number, java.math.BigInteger, and java.math.BigDecimal in Java 1.1 and Java 1.2. @see MathContext @author Mike Cowlishaw @stable ICU 2.0

    public static Map calcTax(DispatchContext dctx, Map context) {
        Map result = new HashMap();
        List items = (List) context.get("itemProductList");
        List amnts = (List) context.get("itemAmountList");
        List ishpn = (List) context.get("itemShippingList");
        BigDecimal shipping = (BigDecimal) context.get("orderShippingAmount");
        GenericValue address = (GenericValue) context.get("shippingAddress");


        if (items.size() != amnts.size()) {
            result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_ERROR);
            result.put(ModelService.ERROR_MESSAGE, "ERROR: Items, Amount, or ItemShipping lists are not valid size.");
            return result;
        }


        try {
            TaxwareUTL utl = new TaxwareUTL();


            utl.setShipping(shipping != null ? shipping : BigDecimal.ZERO);
            utl.setShipAddress(address);
            for (int i = 0; i < items.size(); i++) {
                GenericValue p = (GenericValue) items.get(i);
                BigDecimal amount = (BigDecimal) amnts.get(i);
                BigDecimal ishp = ishpn != null ? (BigDecimal) ishpn.get(i) : BigDecimal.ZERO;


                utl.addItem(p, amount, ishp);
            }


            int resp = utl.process();

View Full Code Here

        }  
        
        // testing 20 decimal places
        pat = ",##0.00000000000000000001";
        dec = new DecimalFormat(pat);
        BigDecimal bignumber = new BigDecimal("8.888888888888888888885");
        expected = "8.88888888888888888889";
        
        dec.setRoundingMode(BigDecimal.ROUND_HALF_UP);
        str = dec.format(bignumber); 
        if (!str.equals(expected)) {

View Full Code Here

        int currentOperationLine = 1;
        // ignore title row
        sc.nextLine();
        currentOperationLine++;


        BigDecimal creditAmount = new BigDecimal(0);
        BigDecimal debitAmount = new BigDecimal(0);


        while (sc.hasNextLine()) {
            Map<String, String> map = new HashMap<String, String>();
            Scanner currentLine = new Scanner(sc.nextLine());
            currentLine.useDelimiter(",");


            String glAccountId = currentLine.next();
            try {
                Integer.parseInt(glAccountId);
                map.put("glAccountId", glAccountId);
            } catch (NumberFormatException ne) {
                String errorMessage = "Balance forward error\nInvalid input at cell A"
                        + currentOperationLine;
                result = ServiceUtil.returnError(errorMessage);
                return result;
            }


            currentLine.next(); // Ignore accountName


            String debit = currentLine.next().toString();


            String credit = "";
            if (debit.equals("") && currentLine.hasNext())
                credit = currentLine.next().toString();


            if (!debit.equals("") && credit.equals("")) {
                try {
                    debitAmount = debitAmount.add(new BigDecimal(debit));
                } catch (NumberFormatException ne) {
                    String errorMessage = "Balance forward error\nInvalid input at cell C"
                            + currentOperationLine;
                    result = ServiceUtil.returnError(errorMessage);
                    return result;
                }
                map.put("amount", debit);
                map.put("debitCreditFlag", "D");
                csvData.add(map);
            } else if (debit.equals("") && !credit.equals("")) {
                try {
                    creditAmount = creditAmount.add(new BigDecimal(credit));
                } catch (NumberFormatException ne) {
                    String errorMessage = "Balance forward error\nInvalid input at cell D"
                            + currentOperationLine;
                    result = ServiceUtil.returnError(errorMessage);
                    return result;
                }
                map.put("amount", credit);
                map.put("debitCreditFlag", "C");
                csvData.add(map);
            }
            currentOperationLine++;
        }


        if (!debitAmount.equals(creditAmount)) {
            String errMsg = "Debit and credit are not equal";
            result = ServiceUtil.returnError(errMsg);
            return result;
        }

View Full Code Here

    {
    }
    
    public void TestBigDecimalFromBigDecimal()
    {
        BigDecimal bigZero = new BigDecimal(0);
        
        try {
            UniversalTimeScale.bigDecimalFrom(bigZero, -1);
            errln("bigDecimalFrom(bigZero, -1) did not throw IllegalArgumentException.");
        } catch (IllegalArgumentException iae) {

View Full Code Here

        }
    }
    
    public void TestToBigDecimalFromBigDecimal()
    {
        BigDecimal bigZero = new BigDecimal(0);
        
        try {
            UniversalTimeScale.toBigDecimal(bigZero, -1);
            errln("toBigDecimal(bigZero, -1) did not throw IllegalArgumentException.");
        } catch (IllegalArgumentException iae) {

View Full Code Here

        }
    }


    public void TestToBigDecimalTrunc()
    {
        BigDecimal bigZero = new BigDecimal(0);
        
        try {
            UniversalTimeScale.toBigDecimalTrunc(bigZero, -1);
            errln("toBigDecimalTrunc(bigZero, -1) did not throw IllegalArgumentException.");
        } catch (IllegalArgumentException iae) {

View Full Code Here

    private long ranMin;
    private long ranMax;
    
    private void initRandom(long min, long max)
    {
        BigDecimal interval = new BigDecimal(max).subtract(new BigDecimal(min));
        
        ranMin = min;
        ranMax = max;
        ranInt = 0;
        
        if (ran == null) {
            ran = createRandom();
        }
        
        if (interval.compareTo(longMax) < 0) {
            ranInt = interval.longValue();
        }
    }

View Full Code Here

     * @param args - the command line arugments
     */
    public static void main(String[] args)
    {
        MessageFormat fmt = new MessageFormat("{0}L, {1}L, {2}L, {3}L");        
        BigDecimal universalMin = new BigDecimal(Long.MIN_VALUE);
        BigDecimal universalMax = new BigDecimal(Long.MAX_VALUE);
        Object limitArgs[] = {null, null, null, null};
        
        System.out.println("\nTo, From limits:");
        
        // from limits
        for(int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {
            BigDecimal min = UniversalTimeScale.toBigDecimalTrunc(universalMin, scale).max(universalMin);
            BigDecimal max = UniversalTimeScale.toBigDecimalTrunc(universalMax, scale).min(universalMax);
            long minLong   = min.longValue();
            long maxLong   = max.longValue();
            
            limitArgs[2] = min.toString();
            limitArgs[3] = max.toString();


            // to limits
            BigDecimal minTrunc   = UniversalTimeScale.bigDecimalFrom(min, scale);
            BigDecimal maxTrunc   = UniversalTimeScale.bigDecimalFrom(max, scale);
            BigDecimal minResidue = minTrunc.subtract(universalMin);
            BigDecimal maxResidue = universalMax.subtract(maxTrunc);
            long units            = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.UNITS_VALUE);
            BigDecimal half       = new BigDecimal(units == 1? 0: units / 2 - 1);
            
            min = minTrunc.subtract(minResidue.min(half));
            max = maxTrunc.add(maxResidue.min(half));
            limitArgs[0] = min.toString();
            limitArgs[1] = max.toString();

View Full Code Here

    private StringBuffer format(BigInteger number, StringBuffer result,
            FieldPosition fieldPosition, boolean parseAttr) {
        // If we are to do rounding, we need to move into the BigDecimal
        // domain in order to do divide/multiply correctly.
        if (roundingIncrementICU != null) {
            return format(new BigDecimal(number), result, fieldPosition);
        }


        if (multiplier != 1) {
            number = number.multiply(BigInteger.valueOf(multiplier));
        }

View Full Code Here

                        (Number) new Long(big.longValue()) : (Number) big;
                }
            }
            // Handle non-integral values or the case where parseBigDecimal is set
            else {
                BigDecimal big = digitList.getBigDecimalICU(status[STATUS_POSITIVE]);
                n = big;
                if (mult != 1) {
                    n = big.divide(BigDecimal.valueOf(mult), mathContext);
                }
            }
        }


        // Assemble into CurrencyAmount if necessary

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of com.ibm.icu.math.BigDecimal

com.ibm.icu.dev.test.format.IntlTestDecimalFormatAPI

com.ibm.icu.dev.test.format.NumberFormatTest

com.ibm.icu.dev.test.serializable.SerializableTest$BigDecimalHandler

com.ibm.icu.dev.test.timescale.TimeScaleAPITest

com.ibm.icu.dev.test.timescale.TimeScaleMonkeyTest

com.ibm.icu.dev.tool.timescale.CalculateLimits

com.ibm.icu.text.DecimalFormat

com.ibm.icu.util.UniversalTimeScale

org.ofbiz.order.thirdparty.taxware.TaxwareServices

org.orangegears.gl.control.setup.LedgerServices

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of com.ibm.icu.math.BigDecimal

Operator methods

Related Classes of com.ibm.icu.math.BigDecimal