/** * Returns a new {@code BigDecimal} whose value is {@code this % divisor}. * <p> * The remainder is defined as {@code this - * this.divideToIntegralValue(divisor) * divisor}. * * @param divisor * value by which {@code this} is divided. * @return {@code this % divisor}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. */ public BigDecimal remainder(BigDecimal divisor) { return divideAndRemainder(divisor)[1]; }
/** * Returns a new {@code BigDecimal} whose value is {@code this % divisor}. * <p> * The remainder is defined as {@code this - * this.divideToIntegralValue(divisor) * divisor}. * <p> * The specified rounding mode {@code mc} is used for the division only. * * @param divisor * value by which {@code this} is divided. * @param mc * rounding mode and precision to be used. * @return {@code this % divisor}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @throws ArithmeticException * if {@code mc.getPrecision() > 0} and the result of {@code * this.divideToIntegralValue(divisor, mc)} requires more digits * to be represented. */ public BigDecimal remainder(BigDecimal divisor, MathContext mc) { return divideAndRemainder(divisor, mc)[1]; }
private Number mod(int maxType, Number left, Number right) { switch (maxType) { case INT: return Integer.valueOf(left.intValue() % right.intValue()); case LONG: return Long.valueOf(left.longValue() % right.longValue()); case FLOAT: return Float.valueOf(left.floatValue() % right.floatValue()); case DOUBLE: return Double.valueOf(left.doubleValue() % right.doubleValue()); case BIGDECIMAL: BigDecimal[] bd = toBigDecimals(left, right); return (bd[0]).divideAndRemainder(bd[1])[1]; } throw new TemplateException("Unsupported data type", location); } }
public static BigDecimal mod(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); return bigDecimals[1]; }
private Object calculate(Object left,char op,Object right){ if((op=='*' || op=='/' || op=='%' || op=='-')){ if(right instanceof String || left instanceof String){ return left.toString()+op+right.toString(); } BigDecimal b1=(BigDecimal)left; BigDecimal b2=(BigDecimal)right; if(op=='*'){ return b1.multiply(b2); }else if(op=='/'){ return b1.divide(b2,10,RoundingMode.HALF_UP).stripTrailingZeros(); }else if(op=='%'){ return b1.divideAndRemainder(b2)[1]; }else if(op=='-'){ return b1.subtract(b2); } }else if(op=='+'){ if(right instanceof String || left instanceof String){ return left.toString()+right.toString(); }else{ BigDecimal b1=(BigDecimal)left; BigDecimal b2=(BigDecimal)right; return b1.add(b2); } } throw new RuntimeException("Unkown operate "+op+""); }
@Property public void roundingUp(@Precision(scale = 8) BigDecimal d) { BigDecimal[] pieces = d.divideAndRemainder(ONE); BigDecimal integral = pieces[0]; BigDecimal fractional = pieces[1]; assumeThat(fractional, greaterThan(new BigDecimal("0.5"))); DollarsAndCents money = new DollarsAndCents(d); assertEquals( integral.add(fractional).setScale(2, HALF_UP), money.toBigDecimal()); } }
@Property public void roundingDown(@Precision(scale = 8) BigDecimal d) { BigDecimal[] pieces = d.divideAndRemainder(ONE); BigDecimal integral = pieces[0]; BigDecimal fractional = pieces[1]; assumeThat(fractional, lessThanOrEqualTo(new BigDecimal("0.5"))); DollarsAndCents money = new DollarsAndCents(d); assertEquals( integral.add(fractional).setScale(2, HALF_DOWN), money.toBigDecimal()); }
public static BigDecimal mod(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); return bigDecimals[1]; }
public static BigDecimal floor(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() < 0) { r = r.add(b1); } return b0.subtract(r); }
public static BigDecimal floor(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() < 0) { r = r.add(b1); } return b0.subtract(r); }
public static BigDecimal ceil(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() > 0) { r = r.subtract(b1); } return b0.subtract(r); }
public static BigDecimal ceil(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() > 0) { r = r.subtract(b1); } return b0.subtract(r); }
public static BigDecimal floor(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() < 0) { r = r.add(b1); } return b0.subtract(r); }
public static BigDecimal ceil(BigDecimal b0, BigDecimal b1) { final BigDecimal[] bigDecimals = b0.divideAndRemainder(b1); BigDecimal r = bigDecimals[1]; if (r.signum() > 0) { r = r.subtract(b1); } return b0.subtract(r); }
long minutes = 230L; BigDecimal min = new BigDecimal(minutes); BigDecimal constant = new BigDecimal(60); BigDecimal[] val=min.divideAndRemainder(constant); System.out.println(val[0]+"."+val[1]+" Hours");
BigDecimal numberOne = new BigDecimal("10"); BigDecimal numberTwo = new BigDecimal("35.55"); BigDecimal[] divRem = numberTwo.divideAndRemainder(numberOne); System.out.println("The second number fits " + divRem[0].stripTrailingZeros().toPlainString() + " times into the first one. The rest is: " + divRem[1].stripTrailingZeros().toPlainString());
/** * BigDecimal compute quotient and remainder. * @param S BigDecimal. * @return BigDecimal[] { q, r } with q = this/S and r = rem(this,S). */ public BigDecimal[] quotientRemainder(BigDecimal S) { BigDecimal[] qr = new BigDecimal[2]; java.math.BigDecimal[] C = val.divideAndRemainder(S.val, context); qr[0] = new BigDecimal(C[0]); qr[1] = new BigDecimal(C[1]); return qr; }
public Decimal[] divideAndRemainder(BigDecimal divisor) { BigDecimal[] result = value.divideAndRemainder(divisor); return new Decimal[]{new Decimal(result[0]), new Decimal(result[1])}; }
@Transient public DecimalAmount dividedBy(BigDecimal o, RemainderHandler remainderHandler) { BigDecimal[] divideAndRemainder = asBigDecimal().divideAndRemainder(o, remainderHandler.getMathContext()); DecimalAmount result = new DecimalAmount(divideAndRemainder[0]); remainderHandler.handleRemainder(result, divideAndRemainder[1]); return result; }
@Override public RoundedMoney[] divideAndRemainder(Number divisor) { BigDecimal bd = MoneyUtils.getBigDecimal(divisor); if (isOne(bd)) { return new RoundedMoney[]{this, new RoundedMoney(0L, getCurrency(), rounding)}; } BigDecimal[] dec = number.divideAndRemainder(MoneyUtils.getBigDecimal(divisor), Optional.ofNullable( monetaryContext.get(MathContext.class)).orElse(MathContext.DECIMAL64)); return new RoundedMoney[]{new RoundedMoney(dec[0], currency, rounding), new RoundedMoney(dec[1], currency, rounding).with(rounding)}; }