Esempio n. 1
14
 /** Constructs a new BigFraction from the given BigDecimal object. */
 public BigFraction(BigDecimal d) {
   this(
       d.scale() < 0
           ? d.unscaledValue().multiply(BigInteger.TEN.pow(-d.scale()))
           : d.unscaledValue(),
       d.scale() < 0 ? BigInteger.ONE : BigInteger.TEN.pow(d.scale()));
 }
 public Money getAdjustmentPrice() {
   return adjustmentPrice == null
       ? null
       : new Money(
           adjustmentPrice,
           delegate.getSubTotal().getCurrency(),
           adjustmentPrice.scale() == 0 ? BankersRounding.DEFAULT_SCALE : adjustmentPrice.scale());
 }
Esempio n. 3
0
 private BigDecimal fixBigDecimal(BigDecimal val) {
   if (val.scale() > 0) {
     val = val.stripTrailingZeros();
     if (val.scale() < 0) {
       val = val.setScale(0);
     }
   }
   return val;
 }
Esempio n. 4
0
  @Override
  protected <T> String internalValueToString(
      final T value,
      final Boolean isNullable,
      final Integer maxLength,
      final Integer precision,
      final Integer scale,
      final Boolean isUnicode)
      throws EdmPrimitiveTypeException {

    String result;
    if (value instanceof Long
        || value instanceof Integer
        || value instanceof Short
        || value instanceof Byte
        || value instanceof BigInteger) {
      result = value.toString();
      final int digits = result.startsWith("-") ? result.length() - 1 : result.length();
      if (precision != null && precision < digits) {
        throw new EdmPrimitiveTypeException(
            "The value '" + value + "' does not match the facets' constraints.");
      }

    } else if (value instanceof Double || value instanceof Float || value instanceof BigDecimal) {
      BigDecimal bigDecimalValue;
      try {
        bigDecimalValue =
            value instanceof Double
                ? BigDecimal.valueOf((Double) value)
                : value instanceof Float ? BigDecimal.valueOf((Float) value) : (BigDecimal) value;
      } catch (final NumberFormatException e) {
        throw new EdmPrimitiveTypeException("The value '" + value + "' is not valid.", e);
      }

      final int digits =
          bigDecimalValue.scale() >= 0
              ? Math.max(bigDecimalValue.precision(), bigDecimalValue.scale())
              : bigDecimalValue.precision() - bigDecimalValue.scale();
      if ((precision == null || precision >= digits)
          && (bigDecimalValue.scale() <= (scale == null ? 0 : scale))) {
        result = bigDecimalValue.toPlainString();
      } else {
        throw new EdmPrimitiveTypeException(
            "The value '" + value + "' does not match the facets' constraints.");
      }

    } else {
      throw new EdmPrimitiveTypeException(
          "The value type " + value.getClass() + " is not supported.");
    }

    return result;
  }
Esempio n. 5
0
 /** @throws Exception */
 public void testGetBigDecimal() throws Exception {
   MockResultSet rs = new MockResultSet();
   ArrayMap rowData = new ArrayMap();
   BigDecimal value = new BigDecimal(1);
   rowData.put("id", value);
   rs.addRowData(rowData);
   assertTrue(rs.next());
   assertEquals(value, rs.getBigDecimal(1));
   assertEquals(value, rs.getBigDecimal("id"));
   BigDecimal value2 = rs.getBigDecimal(1, 2);
   assertEquals(2, value2.scale());
   value2 = rs.getBigDecimal("id", 2);
   assertEquals(2, value2.scale());
 }
Esempio n. 6
0
  /**
   * Constructs a new BigFraction from two BigDecimals.
   *
   * @throws ArithemeticException if denominator == 0.
   */
  private static BigFraction valueOfHelper(
      final BigDecimal numerator, final BigDecimal denominator) {
    // Note: Cannot use .equals(BigDecimal.ZERO), because "0.00" != "0.0".
    if (denominator.unscaledValue().equals(BigInteger.ZERO)) {
      throw new ArithmeticException("Divide by zero: fraction denominator is zero.");
    }

    // Format of BigDecimal: unscaled / 10^scale
    BigInteger tmpNumerator = numerator.unscaledValue();
    BigInteger tmpDenominator = denominator.unscaledValue();

    // (u1/10^s1) / (u2/10^s2) = u1 / (u2 * 10^(s1-s2)) = (u1 * 10^(s2-s1))
    // / u2
    if (numerator.scale() > denominator.scale()) {
      tmpDenominator =
          tmpDenominator.multiply(BigInteger.TEN.pow(numerator.scale() - denominator.scale()));
    } else if (numerator.scale() < denominator.scale()) {
      tmpNumerator =
          tmpNumerator.multiply(BigInteger.TEN.pow(denominator.scale() - numerator.scale()));
      // else: scales are equal, do nothing.
    }

    final BigInteger gcd = tmpNumerator.gcd(tmpDenominator);
    tmpNumerator = tmpNumerator.divide(gcd);
    tmpDenominator = tmpDenominator.divide(gcd);

    if (tmpDenominator.signum() < 0) {
      tmpNumerator = tmpNumerator.negate();
      tmpDenominator = tmpDenominator.negate();
    }

    return new BigFraction(tmpNumerator, tmpDenominator, Reduced.YES);
  }
Esempio n. 7
0
 public BigDecimal getBigDecimal(int scale) throws SQLException {
   truncated_ = 0;
   outOfBounds_ = false;
   if (scale >= 0) {
     if (scale >= value_.scale()) {
       truncated_ = 0;
       outOfBounds_ = false;
       return value_.setScale(scale);
     } else {
       truncated_ = value_.scale() - scale;
       return value_.setScale(scale, BigDecimal.ROUND_HALF_UP);
     }
   } else return value_;
 }
Esempio n. 8
0
 @Override
 public void write(WriteBuffer buff, Object obj) {
   if (!isBigDecimal(obj)) {
     super.write(buff, obj);
     return;
   }
   BigDecimal x = (BigDecimal) obj;
   if (BigDecimal.ZERO.equals(x)) {
     buff.put((byte) TAG_BIG_DECIMAL_0);
   } else if (BigDecimal.ONE.equals(x)) {
     buff.put((byte) TAG_BIG_DECIMAL_1);
   } else {
     int scale = x.scale();
     BigInteger b = x.unscaledValue();
     int bits = b.bitLength();
     if (bits < 64) {
       if (scale == 0) {
         buff.put((byte) TAG_BIG_DECIMAL_SMALL);
       } else {
         buff.put((byte) TAG_BIG_DECIMAL_SMALL_SCALED).putVarInt(scale);
       }
       buff.putVarLong(b.longValue());
     } else {
       byte[] bytes = b.toByteArray();
       buff.put((byte) TYPE_BIG_DECIMAL).putVarInt(scale).putVarInt(bytes.length).put(bytes);
     }
   }
 }
 @Override
 public void write(final ObjectDataOutput out, final BigDecimal obj) throws IOException {
   BigInteger bigInt = obj.unscaledValue();
   int scale = obj.scale();
   bigIntegerSerializer.write(out, bigInt);
   out.writeInt(scale);
 }
  /**
   * @param minValue
   * @param maxValue
   * @param scale
   * @param isForFunctionalBin Functional bins should always be non-sci notation.
   * @return
   */
  public static DecimalFormat getFormat(
      BigDecimal minValue, BigDecimal maxValue, int scale, boolean isForFunctionalBin) {

    // Find number of digits left of decimal
    BigDecimal maxAbs = minValue.abs();
    maxAbs = maxAbs.max(maxValue.abs());
    int digitsLeftOfDecimal = Math.abs(maxAbs.precision() - maxAbs.scale());

    boolean useSciNotation = (digitsLeftOfDecimal > 4 || scale > 4) && !isForFunctionalBin;

    String formatStr = null;

    if (useSciNotation) {
      if (scale > 0) {
        // Sig figs beyond the decimal (decimal fraction number)
        formatStr = "0." + StringUtils.repeat("0", scale) + "E0";
      } else {
        // will contain no decimal number
        formatStr = "##0.##E0";
      }
    } else {
      if (scale > 0) {
        // Sig figs beyond the decimal (decimal fraction number)
        formatStr = "0." + StringUtils.repeat("0", scale);
      } else {
        // will contain no decimal number
        formatStr = "0";
      }
    }

    return new DecimalFormat(formatStr);
  }
 @Override
 public ByteBuffer write(ByteBuffer buff, Object obj) {
   if (!isBigDecimal(obj)) {
     return super.write(buff, obj);
   }
   BigDecimal x = (BigDecimal) obj;
   if (BigDecimal.ZERO.equals(x)) {
     buff.put((byte) TAG_BIG_DECIMAL_0);
   } else if (BigDecimal.ONE.equals(x)) {
     buff.put((byte) TAG_BIG_DECIMAL_1);
   } else {
     int scale = x.scale();
     BigInteger b = x.unscaledValue();
     int bits = b.bitLength();
     if (bits < 64) {
       if (scale == 0) {
         buff.put((byte) TAG_BIG_DECIMAL_SMALL);
       } else {
         buff.put((byte) TAG_BIG_DECIMAL_SMALL_SCALED);
         DataUtils.writeVarInt(buff, scale);
       }
       DataUtils.writeVarLong(buff, b.longValue());
     } else {
       buff.put((byte) TYPE_BIG_DECIMAL);
       DataUtils.writeVarInt(buff, scale);
       byte[] bytes = b.toByteArray();
       DataUtils.writeVarInt(buff, bytes.length);
       buff = DataUtils.ensureCapacity(buff, bytes.length);
       buff.put(bytes);
     }
   }
   return buff;
 }
Esempio n. 12
0
  private static BigInteger getNearby(BigInteger significand, int binExp, int offset) {
    int nExtraBits = 1;
    int nDec = (int) Math.round(3.0 + (64 + nExtraBits) * Math.log10(2.0));
    BigInteger newFrac = significand.shiftLeft(nExtraBits).add(BigInteger.valueOf(offset));

    int gg = 64 + nExtraBits - binExp - 1;

    BigDecimal bd = new BigDecimal(newFrac);
    if (gg > 0) {
      bd = bd.divide(new BigDecimal(BigInteger.ONE.shiftLeft(gg)));
    } else {
      BigInteger frac = newFrac;
      while (frac.bitLength() + binExp < 180) {
        frac = frac.multiply(BigInteger.TEN);
      }
      int binaryExp = binExp - newFrac.bitLength() + frac.bitLength();

      bd = new BigDecimal(frac.shiftRight(frac.bitLength() - binaryExp - 1));
    }
    int excessPrecision = bd.precision() - nDec;
    if (excessPrecision > 0) {
      bd = bd.setScale(bd.scale() - excessPrecision, BigDecimal.ROUND_HALF_UP);
    }
    return bd.unscaledValue();
  }
Esempio n. 13
0
 /**
  * The constructor does not complex computations and requires simple, inputs consistent with the
  * class invariant. Other creation methods are available for convenience.
  */
 public Money(BigDecimal amount, Currency currency) {
   if (amount.scale() != currency.getDefaultFractionDigits()) {
     throw new IllegalArgumentException("Scale of amount does not match currency");
   }
   this.currency = currency;
   this.amount = amount;
 }
 private static short[] pgNumericVar(BigDecimal n) {
   short ndigits, weight, sign, dscale;
   dscale = (short) n.scale();
   if (dscale < 0) dscale = 0;
   String s = n.toPlainString();
   int lpos = 0;
   sign = NUMERIC_POS;
   if (s.charAt(lpos) == '-') {
     sign = NUMERIC_NEG;
     lpos++;
   }
   int dposl = s.indexOf('.', lpos), dposr;
   if (dposl < 0) dposr = dposl = s.length();
   else dposr = dposl + 1;
   int nleft = (dposl - lpos + 3) / 4;
   weight = (short) (nleft - 1);
   int nright = (s.length() - dposr + 3) / 4;
   ndigits = (short) (nleft + nright);
   while ((ndigits > 0)
       && (pgNumericDigit(s, ndigits - 1, lpos, dposl, dposr, nleft, nright) == 0)) {
     ndigits--;
   }
   short[] digits = new short[ndigits + 4];
   digits[0] = ndigits;
   digits[1] = weight;
   digits[2] = sign;
   digits[3] = dscale;
   for (int i = 0; i < ndigits; i++) {
     digits[i + 4] = pgNumericDigit(s, i, lpos, dposl, dposr, nleft, nright);
   }
   return digits;
 }
Esempio n. 15
0
 /**
  * Convert a BigDecimal value to a byte array
  *
  * @param val
  * @return the byte array
  */
 public static byte[] toBytes(BigDecimal val) {
   byte[] valueBytes = val.unscaledValue().toByteArray();
   byte[] result = new byte[valueBytes.length + SIZEOF_INT];
   int offset = putInt(result, 0, val.scale());
   putBytes(result, offset, valueBytes, 0, valueBytes.length);
   return result;
 }
Esempio n. 16
0
  public static DecBase toDec(BigDecimal bd) {
    boolean bPositive = true;

    if (bd.signum() < 0) bPositive = false;

    String sValue = bd.abs().unscaledValue().toString();
    int nScale = bd.scale();
    if (sValue.length() > nScale) {
      String sInt = sValue.substring(0, sValue.length() - nScale);
      String sDec = sValue.substring(sValue.length() - nScale);
      DecBase dec = new DecBase(sInt, sDec);
      dec.setPositive(bPositive);
      return dec;
    } else {
      String sDec = new String();
      int nNbLeadingZeros = nScale - sValue.length();
      for (int n = 0; n < nNbLeadingZeros; n++) {
        sDec = sDec + "0";
      }
      sDec = sDec + sValue;

      DecBase dec = new DecBase(0, sDec);
      dec.setPositive(bPositive);
      return dec;
    }
  }
 public static String castToString(BigDecimal val) {
   int sign = val.signum();
   val = val.abs();
   String s = val.unscaledValue().toString();
   while (s.length() <= val.scale()) s = "0" + s;
   while (s.length() < -val.scale()) s = s + "0";
   if (val.scale() > 0) {
     s =
         s.substring(0, s.length() - val.scale())
             + "."
             + s.substring(s.length() - val.scale(), s.length());
     while (s.endsWith("0")) s = s.substring(0, s.length() - 1);
     if (s.endsWith(".")) s = s.substring(0, s.length() - 1);
   }
   if (sign < 0) s = "-" + s;
   return s;
 }
Esempio n. 18
0
 @Override
 public int getDecimalScale() {
   BigDecimal d = getDecimal();
   if (d != null) {
     return d.scale();
   }
   return 0;
 }
 public CalculatorToken(BigDecimal v, boolean approx) {
   this.value = v;
   this.isApprox = approx;
   if (approx) {
     this.minScale = v.scale();
     this.minPrecision = v.precision();
   }
 }
  @Test
  public void testConvertToWalletAmount() {
    WalletAmountConverter wac = new WalletAmountConverter(2);

    BigDecimal a = wac.convertToWalletAmount(-12345);
    assertEquals(new BigDecimal("-123.45"), a);
    assertEquals(2, a.scale());
  }
  @Override
  public void comply(final E object) throws Exception {
    if (object == null) return;
    final int integerPartLength;
    final int fractionPartLength;
    try {
      final BigDecimal bigNum;
      if (object instanceof BigDecimal) bigNum = (BigDecimal) object;
      else bigNum = new BigDecimal(object.toString()).stripTrailingZeros();

      integerPartLength = bigNum.precision() - bigNum.scale();
      fractionPartLength = bigNum.scale() < 0 ? 0 : bigNum.scale();
    } catch (Exception ex) {
      throw ex;
    }

    if (maxIntegerLength < integerPartLength || maxFractionLength < fractionPartLength) throw ex;
  }
 @Override
 protected void writeObject(ObjectOutput out, Object obj) throws IOException {
   BigDecimal val = (BigDecimal) obj;
   out.writeInt(val.scale());
   BigInteger unscaled = val.unscaledValue();
   byte[] bytes = unscaled.toByteArray();
   out.writeInt(bytes.length);
   out.write(bytes);
 }
Esempio n. 23
0
 public static double calcIncrement(double value) {
   BigDecimal b = BigDecimal.valueOf(value);
   BigDecimal r = b.remainder(BigDecimal.ONE);
   if (r.compareTo(BigDecimal.ZERO) == 0) {
     return 1;
   }
   double res = 1 / Math.pow(10, r.scale());
   return res;
 }
Esempio n. 24
0
 public BigDecimal getBigDecimal(int scale) throws SQLException {
   truncated_ = 0;
   try {
     BigDecimal bigDecimal = new BigDecimal(SQLDataFactory.convertScientificNotation(value_));
     if (scale >= 0) {
       if (scale >= bigDecimal.scale()) {
         truncated_ = 0;
         return bigDecimal.setScale(scale);
       } else {
         truncated_ = bigDecimal.scale() - scale;
         return bigDecimal.setScale(scale, BigDecimal.ROUND_HALF_UP);
       }
     } else return bigDecimal;
   } catch (NumberFormatException e) {
     JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH, e);
     return null;
   }
 }
Esempio n. 25
0
 protected BigDecimal roundCost(BigDecimal price, int C_AcctSchema_ID) {
   // Fix Cost Precision
   int precision = MAcctSchema.get(Env.getCtx(), C_AcctSchema_ID).getCostingPrecision();
   BigDecimal priceRounded = price;
   if (priceRounded.scale() > precision) {
     priceRounded = priceRounded.setScale(precision, RoundingMode.HALF_UP);
   }
   return priceRounded;
 }
 /**
  * Returns the scale (ie the BigDecimal concept of scale) of the most significant digit of the
  * value.
  *
  * <p>Examples:
  *
  * <ul>
  *   <li>The scale of 1.49523 is 0
  *   <li>The scale of 0.149523 is 1
  *   <li>The scale of 14.9523 is -1
  *   <li>The scale of 0 is 0
  *
  * @param value
  * @return
  */
 public static int getScaleOfMostSignificantDigit(BigDecimal value) {
   if (value.compareTo(BigDecimal.ZERO) == 0) {
     // Some multi-decimal place forms of zero return a non-zero result
     // for the equation below, even when stripped.
     return 0;
   } else {
     return value.scale() - value.precision() + 1;
   }
 }
Esempio n. 27
0
 public static String getBaseDecimal(ExpandedDouble hd) {
   int gg = 64 - hd.getBinaryExponent() - 1;
   BigDecimal bd =
       new BigDecimal(hd.getSignificand()).divide(new BigDecimal(BigInteger.ONE.shiftLeft(gg)));
   int excessPrecision = bd.precision() - 23;
   if (excessPrecision > 0) {
     bd = bd.setScale(bd.scale() - excessPrecision, BigDecimal.ROUND_HALF_UP);
   }
   return bd.unscaledValue().toString();
 }
Esempio n. 28
0
 public static SMTAffineTerm create(Rational factor, Term subterm) {
   Sort sort = subterm.getSort();
   Map<Term, Rational> summands;
   Rational constant;
   if (factor.equals(Rational.ZERO)) {
     summands = Collections.emptyMap();
     constant = Rational.ZERO;
   } else if (subterm instanceof SMTAffineTerm) {
     SMTAffineTerm a = (SMTAffineTerm) subterm;
     constant = a.mConstant.mul(factor);
     summands = new HashMap<Term, Rational>();
     for (Map.Entry<Term, Rational> me : a.mSummands.entrySet()) {
       summands.put(me.getKey(), me.getValue().mul(factor));
     }
   } else if (subterm instanceof ConstantTerm) {
     Object value = ((ConstantTerm) subterm).getValue();
     if (value instanceof BigInteger) {
       constant = Rational.valueOf((BigInteger) value, BigInteger.ONE).mul(factor);
       summands = Collections.emptyMap();
     } else if (value instanceof BigDecimal) {
       BigDecimal decimal = (BigDecimal) value;
       if (decimal.scale() <= 0) {
         BigInteger num = decimal.toBigInteger();
         constant = Rational.valueOf(num, BigInteger.ONE).mul(factor);
       } else {
         BigInteger num = decimal.unscaledValue();
         BigInteger denom = BigInteger.TEN.pow(decimal.scale());
         constant = Rational.valueOf(num, denom).mul(factor);
       }
       summands = Collections.emptyMap();
     } else if (value instanceof Rational) {
       constant = (Rational) value;
       summands = Collections.emptyMap();
     } else {
       summands = Collections.singletonMap(subterm, factor);
       constant = Rational.ZERO;
     }
   } else {
     summands = Collections.singletonMap(subterm, factor);
     constant = Rational.ZERO;
   }
   return create(summands, constant, sort);
 }
Esempio n. 29
0
 public final BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
   BigDecimal dec = getBigDecimal(columnIndex);
   if (dec == null) {
     return null;
   }
   if (dec.scale() != scale) {
     return dec.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
   }
   return dec;
 }
Esempio n. 30
0
  /**
   * Put a BigDecimal value out to the specified byte array position.
   *
   * @param bytes the byte array
   * @param offset position in the array
   * @param val BigDecimal to write out
   * @return incremented offset
   */
  public static int putBigDecimal(byte[] bytes, int offset, BigDecimal val) {
    if (bytes == null) {
      return offset;
    }

    byte[] valueBytes = val.unscaledValue().toByteArray();
    byte[] result = new byte[valueBytes.length + SIZEOF_INT];
    offset = putInt(result, offset, val.scale());
    return putBytes(result, offset, valueBytes, 0, valueBytes.length);
  }