Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testCalculate() { assertEquals(0.5, EquityMultiplier.calculate(TOTAL_ASSETS, EQUITY).doubleValue()); }
public static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity) { BigDecimal totalAssetValue = BigDecimal.valueOf(totalAssets.getNumber().doubleValueExact()); BigDecimal equityValue = BigDecimal.valueOf(equity.getNumber().doubleValueExact()); return totalAssetValue.divide(equityValue, MathContext.DECIMAL64); }
EquityMultiplier { public static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity) { BigDecimal totalAssetValue = BigDecimal.valueOf(totalAssets.getNumber().doubleValueExact()); BigDecimal equityValue = BigDecimal.valueOf(equity.getNumber().doubleValueExact()); return totalAssetValue.divide(equityValue, MathContext.DECIMAL64); } }
EquityMultiplier { public static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity) { BigDecimal totalAssetValue = BigDecimal.valueOf(totalAssets.getNumber().doubleValueExact()); BigDecimal equityValue = BigDecimal.valueOf(equity.getNumber().doubleValueExact()); return totalAssetValue.divide(equityValue, MathContext.DECIMAL64); } private EquityMultiplier(); }
EquityMultiplier { public static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity) { BigDecimal totalAssetValue = BigDecimal.valueOf(totalAssets.getNumber().doubleValueExact()); BigDecimal equityValue = BigDecimal.valueOf(equity.getNumber().doubleValueExact()); return totalAssetValue.divide(equityValue, MathContext.DECIMAL64); } private EquityMultiplier(); static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity); }
EquityMultiplier { public static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity) { BigDecimal totalAssetValue = BigDecimal.valueOf(totalAssets.getNumber().doubleValueExact()); BigDecimal equityValue = BigDecimal.valueOf(equity.getNumber().doubleValueExact()); return totalAssetValue.divide(equityValue, MathContext.DECIMAL64); } private EquityMultiplier(); static BigDecimal calculate(MonetaryAmount totalAssets, MonetaryAmount equity); }
@Test public void testCalculateWithRegression() { assertEquals(Rate.of(0.301), CapitalAssetPricingModelFormula.calculate(RISKFREE_RATE, BETA, MARKET_RETURN, EPSILON)); }
public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn, BigDecimal epsilon); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn, BigDecimal epsilon); }
@Test public void testCalculate() { assertEquals(Rate.of(0.3), CapitalAssetPricingModelFormula.calculate(RISKFREE_RATE, BETA, MARKET_RETURN)); }
public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn, BigDecimal epsilon); }
CapitalAssetPricingModelFormula { public static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn) { return calculate(riskFreeRate, beta, marketReturn, BigDecimal.ZERO); } private CapitalAssetPricingModelFormula(); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn); static Rate calculate(Rate riskFreeRate, BigDecimal beta, Rate marketReturn, BigDecimal epsilon); }
@Test public void testCalculate() { assertEquals(Money.of(400, "GBP"), PreferredStock.calculate(DIVIDEND, DISCOUNT_RATE)); }
public static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate) { return dividend.divide(discountRate.get()); }
PreferredStock implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate) { return dividend.divide(discountRate.get()); } }
PreferredStock implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate) { return dividend.divide(discountRate.get()); } private PreferredStock(Rate discountRate); }
PreferredStock implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate) { return dividend.divide(discountRate.get()); } private PreferredStock(Rate discountRate); Rate getDiscountRate(); static PreferredStock of(Rate discountRate); static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate); @Override MonetaryAmount apply(MonetaryAmount dividend); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
PreferredStock implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate) { return dividend.divide(discountRate.get()); } private PreferredStock(Rate discountRate); Rate getDiscountRate(); static PreferredStock of(Rate discountRate); static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate); @Override MonetaryAmount apply(MonetaryAmount dividend); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testApply() { assertEquals(Money.of(400, "GBP"), DIVIDEND.with(PreferredStock.of(DISCOUNT_RATE))); }
@Override public MonetaryAmount apply(MonetaryAmount dividend) { return calculate(dividend, discountRate); }
PreferredStock implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount dividend) { return calculate(dividend, discountRate); } }
PreferredStock implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount dividend) { return calculate(dividend, discountRate); } private PreferredStock(Rate discountRate); }
PreferredStock implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount dividend) { return calculate(dividend, discountRate); } private PreferredStock(Rate discountRate); Rate getDiscountRate(); static PreferredStock of(Rate discountRate); static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate); @Override MonetaryAmount apply(MonetaryAmount dividend); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
PreferredStock implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount dividend) { return calculate(dividend, discountRate); } private PreferredStock(Rate discountRate); Rate getDiscountRate(); static PreferredStock of(Rate discountRate); static MonetaryAmount calculate(MonetaryAmount dividend, Rate discountRate); @Override MonetaryAmount apply(MonetaryAmount dividend); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testCalculate() { assertEquals(Money.of(100, "GBP"), ZeroCouponBondValue.calculate(FACE, RATE, NUMBER_OF_YEARS_TO_MATURITY)); }
public static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity) { return face.divide(BigDecimal.ONE.add(rate.get()).pow(numberOfYearsToMaturity)); }
ZeroCouponBondValue implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity) { return face.divide(BigDecimal.ONE.add(rate.get()).pow(numberOfYearsToMaturity)); } }
ZeroCouponBondValue implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity) { return face.divide(BigDecimal.ONE.add(rate.get()).pow(numberOfYearsToMaturity)); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); }
ZeroCouponBondValue implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity) { return face.divide(BigDecimal.ONE.add(rate.get()).pow(numberOfYearsToMaturity)); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); Rate getRate(); int getNumberOfYearsToMaturity(); static ZeroCouponBondValue of(Rate rate, int numberOfYearsToMaturity); static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity); @Override MonetaryAmount apply(MonetaryAmount face); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
ZeroCouponBondValue implements MonetaryOperator { public static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity) { return face.divide(BigDecimal.ONE.add(rate.get()).pow(numberOfYearsToMaturity)); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); Rate getRate(); int getNumberOfYearsToMaturity(); static ZeroCouponBondValue of(Rate rate, int numberOfYearsToMaturity); static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity); @Override MonetaryAmount apply(MonetaryAmount face); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void calculate_onePeriods() throws Exception { ContinuousCompoundInterest ci = ContinuousCompoundInterest.of( RateAndPeriods.of(0.05,1) ); assertEquals(Money.of(1,"CHF").with(ci).getNumber().doubleValue(), 0.0512d, 0.0001d); assertEquals(Money.of(0,"CHF").with(ci).getNumber().doubleValue(), 0.0d, 0.000d); assertEquals(Money.of(-1,"CHF").with(ci).getNumber().doubleValue(), -0.0512d, 0.0001d); }
public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testApply() { assertEquals(Money.of(100, "GBP"), FACE.with(ZeroCouponBondValue.of(RATE, NUMBER_OF_YEARS_TO_MATURITY))); }
@Override public MonetaryAmount apply(MonetaryAmount face) { return calculate(face, rate, numberOfYearsToMaturity); }
ZeroCouponBondValue implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount face) { return calculate(face, rate, numberOfYearsToMaturity); } }
ZeroCouponBondValue implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount face) { return calculate(face, rate, numberOfYearsToMaturity); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); }
ZeroCouponBondValue implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount face) { return calculate(face, rate, numberOfYearsToMaturity); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); Rate getRate(); int getNumberOfYearsToMaturity(); static ZeroCouponBondValue of(Rate rate, int numberOfYearsToMaturity); static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity); @Override MonetaryAmount apply(MonetaryAmount face); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
ZeroCouponBondValue implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount face) { return calculate(face, rate, numberOfYearsToMaturity); } private ZeroCouponBondValue(Rate rate, int numberOfYearsToMaturity); Rate getRate(); int getNumberOfYearsToMaturity(); static ZeroCouponBondValue of(Rate rate, int numberOfYearsToMaturity); static MonetaryAmount calculate(MonetaryAmount face, Rate rate, int numberOfYearsToMaturity); @Override MonetaryAmount apply(MonetaryAmount face); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testCalculate() { assertEquals(BigDecimal.valueOf(0.1125), YieldToMaturity.calculate(COUPON_PAYMENT_AMOUNT, FACE_AMOUNT, PRICE_AMOUNT, NUMBER_OF_YEARS_TO_MATURITY)); }
public static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity) { final BigDecimal coupon = BigDecimal.valueOf(couponPaymentAmount.getNumber().doubleValueExact()); final BigDecimal face = BigDecimal.valueOf(faceAmount.getNumber().doubleValueExact()); final BigDecimal price = BigDecimal.valueOf(priceAmount.getNumber().doubleValueExact()); final BigDecimal averagedDifference = face.subtract(price).divide(BigDecimal.valueOf(numberOfYearsToMaturity), MathContext.DECIMAL64); final BigDecimal averagePrice = face.add(price).divide(BigDecimal.valueOf(2), MathContext.DECIMAL64); return coupon.add(averagedDifference).divide(averagePrice, MathContext.DECIMAL64); }
YieldToMaturity { public static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity) { final BigDecimal coupon = BigDecimal.valueOf(couponPaymentAmount.getNumber().doubleValueExact()); final BigDecimal face = BigDecimal.valueOf(faceAmount.getNumber().doubleValueExact()); final BigDecimal price = BigDecimal.valueOf(priceAmount.getNumber().doubleValueExact()); final BigDecimal averagedDifference = face.subtract(price).divide(BigDecimal.valueOf(numberOfYearsToMaturity), MathContext.DECIMAL64); final BigDecimal averagePrice = face.add(price).divide(BigDecimal.valueOf(2), MathContext.DECIMAL64); return coupon.add(averagedDifference).divide(averagePrice, MathContext.DECIMAL64); } }
YieldToMaturity { public static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity) { final BigDecimal coupon = BigDecimal.valueOf(couponPaymentAmount.getNumber().doubleValueExact()); final BigDecimal face = BigDecimal.valueOf(faceAmount.getNumber().doubleValueExact()); final BigDecimal price = BigDecimal.valueOf(priceAmount.getNumber().doubleValueExact()); final BigDecimal averagedDifference = face.subtract(price).divide(BigDecimal.valueOf(numberOfYearsToMaturity), MathContext.DECIMAL64); final BigDecimal averagePrice = face.add(price).divide(BigDecimal.valueOf(2), MathContext.DECIMAL64); return coupon.add(averagedDifference).divide(averagePrice, MathContext.DECIMAL64); } private YieldToMaturity(); }
YieldToMaturity { public static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity) { final BigDecimal coupon = BigDecimal.valueOf(couponPaymentAmount.getNumber().doubleValueExact()); final BigDecimal face = BigDecimal.valueOf(faceAmount.getNumber().doubleValueExact()); final BigDecimal price = BigDecimal.valueOf(priceAmount.getNumber().doubleValueExact()); final BigDecimal averagedDifference = face.subtract(price).divide(BigDecimal.valueOf(numberOfYearsToMaturity), MathContext.DECIMAL64); final BigDecimal averagePrice = face.add(price).divide(BigDecimal.valueOf(2), MathContext.DECIMAL64); return coupon.add(averagedDifference).divide(averagePrice, MathContext.DECIMAL64); } private YieldToMaturity(); static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity); }
YieldToMaturity { public static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity) { final BigDecimal coupon = BigDecimal.valueOf(couponPaymentAmount.getNumber().doubleValueExact()); final BigDecimal face = BigDecimal.valueOf(faceAmount.getNumber().doubleValueExact()); final BigDecimal price = BigDecimal.valueOf(priceAmount.getNumber().doubleValueExact()); final BigDecimal averagedDifference = face.subtract(price).divide(BigDecimal.valueOf(numberOfYearsToMaturity), MathContext.DECIMAL64); final BigDecimal averagePrice = face.add(price).divide(BigDecimal.valueOf(2), MathContext.DECIMAL64); return coupon.add(averagedDifference).divide(averagePrice, MathContext.DECIMAL64); } private YieldToMaturity(); static BigDecimal calculate(MonetaryAmount couponPaymentAmount, MonetaryAmount faceAmount, MonetaryAmount priceAmount, int numberOfYearsToMaturity); }
@Test public void testCalculate() { assertEquals(Money.of(200, "GBP"), EstimatedEarnings.calculate(FORECASTED_SALES, FORECASTED_EXPENSES)); }
public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses); static MonetaryAmount calculate(MonetaryAmount projectedSales, BigDecimal projectedNetProfitMargin); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses); static MonetaryAmount calculate(MonetaryAmount projectedSales, BigDecimal projectedNetProfitMargin); }
@Test public void testCalculateWithProfitMarginFormula() { assertEquals(Money.of(2, "GBP"), EstimatedEarnings.calculate(PROJECTED_SALES, PROJECTED_NET_PROFIT_MARGIN)); }
public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses); static MonetaryAmount calculate(MonetaryAmount projectedSales, BigDecimal projectedNetProfitMargin); }
EstimatedEarnings { public static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses) { return forecastedSales.subtract(forecastedExpenses); } private EstimatedEarnings(); static MonetaryAmount calculate(MonetaryAmount forecastedSales, MonetaryAmount forecastedExpenses); static MonetaryAmount calculate(MonetaryAmount projectedSales, BigDecimal projectedNetProfitMargin); }
@Test public void calculate_twoPeriods() throws Exception { ContinuousCompoundInterest ci = ContinuousCompoundInterest.of( RateAndPeriods.of(0.05,2) ); assertEquals(Money.of(1,"CHF").with(ci).getNumber().doubleValue(), 0.10517064178387361, 0.000000001d); assertEquals(Money.of(0,"CHF").with(ci).getNumber().doubleValue(),0d, 0.0d); assertEquals(Money.of(-1,"CHF").with(ci).getNumber().doubleValue(), -0.10517064178387361, 0.000000001d); }
public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { public static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods) { return new ContinuousCompoundInterest(rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { ContinuousCompoundInterest ci = ContinuousCompoundInterest.of( RateAndPeriods.of(0.1,2) ); assertEquals(ci.apply(Money.of(1000,"CHF")) .getNumber().doubleValue(), Money.of(221.401536766165,"CHF").getNumber().doubleValue(), 0.00d); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
ContinuousCompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private ContinuousCompoundInterest(RateAndPeriods rateAndPeriods); static ContinuousCompoundInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void getRate() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.03,1) ); assertEquals(val.getRate(), Rate.of(0.03)); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void getPeriods() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.03,3654) ); assertEquals(val.getPeriods(), 3654); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_zeroPeriods() throws Exception { AnnualPercentageYield ci = AnnualPercentageYield.of( Rate.of(0.05),0 ); }
public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_Period1() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 1) ); assertNotNull(val); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_Period0() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.08,0) ); assertNotNull(val); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods0() throws Exception { Money m = Money.of(100, "CHF"); PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods1() throws Exception { Money m = Money.of(100, "CHF"); PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 1) ); assertEquals(Money.of(100,"CHF"), m.with(val)); val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 1) ); assertEquals(Money.of(100,"CHF"), m.with(val)); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_PeriodsN() throws Exception { Money m = Money.of(100, "CHF"); PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 10) ); assertEquals(Money.of(810.7821675644053,"CHF").getNumber().numberValue(BigDecimal.class) .doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class) .doubleValue(), 0.00000000000001d); val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 10) ); assertEquals(Money.of(1273.3468832186768,"CHF").getNumber().numberValue(BigDecimal.class).doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class).doubleValue(), 0.000000000000001d); }
public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new PresentValueOfAnnuityDue(rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.08, 10) ); Money m = Money.of(100, "CHF"); assertEquals(val.apply(m), m.with(val)); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void toStringTest() throws Exception { PresentValueOfAnnuityDue val = PresentValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 10) ); assertEquals("PresentValueOfAnnuityDue{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=10}}", val.toString()); }
@Override public String toString() { return "PresentValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private PresentValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static PresentValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_notNull() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,1) ); assertNotNull(ci); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctRate() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.0234,1) ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.0234)); ci = CompoundInterest.of( RateAndPeriods.of(0.05,1) ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.05)); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctPeriods() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,1) ); assertEquals(ci.getPeriods(), 1); ci = CompoundInterest.of( RateAndPeriods.of(0.05,234) ); assertEquals(ci.getPeriods(), 234); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_twoPeriods() throws Exception { AnnualPercentageYield ci = AnnualPercentageYield.of( Rate.of(0.05),2 ); assertEquals(Money.of(1,"CHF").with(ci),Money.of(0.050625,"CHF")); assertEquals(Money.of(0,"CHF").with(ci),Money.of(0.0,"CHF")); assertEquals(Money.of(-1,"CHF").with(ci),Money.of(-0.050625,"CHF")); }
public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
AnnualPercentageYield implements MonetaryOperator { public static AnnualPercentageYield of(Rate rate, int periods){ return new AnnualPercentageYield(rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_zeroPeriods() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,0) ); assertEquals(Money.of(10.03,"CHF").with(ci), Money.of(0,"CHF")); assertEquals(Money.of(0,"CHF").with(ci), Money.of(0,"CHF")); assertEquals(Money.of(-20.45,"CHF").with(ci), Money.of(0,"CHF")); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_onePeriods() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,1) ); assertEquals(Money.of(1,"CHF").with(ci),Money.of(0.05,"CHF")); assertEquals(Money.of(0,"CHF").with(ci),Money.of(0,"CHF")); assertEquals(Money.of(-1,"CHF").with(ci),Money.of(-0.05,"CHF")); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_twoPeriods() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,2) ); assertEquals(Money.of(1,"CHF").with(ci),Money.of(0.1025,"CHF")); assertEquals(Money.of(0,"CHF").with(ci),Money.of(0,"CHF")); assertEquals(Money.of(-1,"CHF").with(ci),Money.of(-0.1025,"CHF")); }
public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { public static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded) { return new CompoundInterest(rateAndPeriods, timesCompounded); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { CompoundInterest ci = CompoundInterest.of( RateAndPeriods.of(0.05,2) ); assertEquals(ci.apply(Money.of(1,"CHF")),Money.of(0.1025,"CHF")); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
CompoundInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private CompoundInterest(RateAndPeriods rateAndPeriods, int timesCompounded); int getTimesCompounded(); static CompoundInterest of(RateAndPeriods rateAndPeriods, int timesCompounded); static CompoundInterest of(RateAndPeriods rateAndperiods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods, int timesCompounded); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testApply(){ PresentValueOfPerpetuity op = PresentValueOfPerpetuity.of(Rate.of(0.05)); assertEquals(Money.of(2000, "CHF"), Money.of(100, "CHF").with(op)); assertEquals(Money.of(2000, "CHF"), op.apply(Money.of(100, "CHF"))); assertEquals(Money.of(-2000, "CHF"), Money.of(-100, "CHF").with(op)); op = PresentValueOfPerpetuity.of(Rate.of(-0.05)); assertEquals(Money.of(-2000, "CHF"), op.apply(Money.of(100, "CHF"))); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate); }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate); } }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate); } private PresentValueOfPerpetuity(Rate rate); }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate); } private PresentValueOfPerpetuity(Rate rate); Rate getRate(); static PresentValueOfPerpetuity of(Rate rate); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate); } private PresentValueOfPerpetuity(Rate rate); Rate getRate(); static PresentValueOfPerpetuity of(Rate rate); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testToString(){ PresentValueOfPerpetuity op = PresentValueOfPerpetuity.of(Rate.of(0.056778)); assertEquals("PresentValueOfPerpetuity{rate=Rate[0.056778]}", op.toString()); }
@Override public String toString() { return "PresentValueOfPerpetuity{" + "rate=" + rate + '}'; }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public String toString() { return "PresentValueOfPerpetuity{" + "rate=" + rate + '}'; } }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public String toString() { return "PresentValueOfPerpetuity{" + "rate=" + rate + '}'; } private PresentValueOfPerpetuity(Rate rate); }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public String toString() { return "PresentValueOfPerpetuity{" + "rate=" + rate + '}'; } private PresentValueOfPerpetuity(Rate rate); Rate getRate(); static PresentValueOfPerpetuity of(Rate rate); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueOfPerpetuity implements MonetaryOperator { @Override public String toString() { return "PresentValueOfPerpetuity{" + "rate=" + rate + '}'; } private PresentValueOfPerpetuity(Rate rate); Rate getRate(); static PresentValueOfPerpetuity of(Rate rate); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void getRate() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.03,1) ); assertEquals(val.getRate(), Rate.of(0.03)); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void getPeriods() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.03,3654) ); assertEquals(val.getPeriods(), 3654); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_Period1() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 1) ); assertNotNull(val); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_Period0() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.08,0) ); assertNotNull(val); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { AnnualPercentageYield ci = AnnualPercentageYield.of( Rate.of(0.05),2 ); assertEquals(ci.apply(Money.of(1,"CHF")),Money.of(0.050625,"CHF")); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate, periods); }
AnnualPercentageYield implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate, periods); } }
AnnualPercentageYield implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate, periods); } private AnnualPercentageYield(Rate rate, int periods); }
AnnualPercentageYield implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
AnnualPercentageYield implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rate, periods); } private AnnualPercentageYield(Rate rate, int periods); int getPeriods(); Rate getRate(); static AnnualPercentageYield of(Rate rate, int periods); static Rate calculate(Rate rate, int periods); static MonetaryAmount calculate(MonetaryAmount amount, Rate rate, int periods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods0() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods1() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 1) ); assertEquals(Money.of(10.50,"CHF"), m.with(val)); val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 1) ); assertEquals(Money.of(9.5,"CHF"), m.with(val)); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_PeriodsN() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 10) ); assertEquals(Money.of(132.06787162326262,"CHF").getNumber().numberValue(BigDecimal.class) .doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class) .doubleValue(), 0.00000000000001d); val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(-0.05, 10) ); assertEquals(Money.of(76.23998154470802,"CHF").getNumber().numberValue(BigDecimal.class).doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class).doubleValue(), 0.000000000000001d); }
public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuityDue(rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.08, 10) ); Money m = Money.of(10, "CHF"); assertEquals(val.apply(m), m.with(val)); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void toStringTest() throws Exception { FutureValueOfAnnuityDue val = FutureValueOfAnnuityDue.of( RateAndPeriods.of(0.05, 10) ); assertEquals("FutureValueOfAnnuityDue{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=10}}", val.toString()); }
@Override public String toString() { return "FutureValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuityDue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuityDue{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuityDue(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuityDue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_PositiveRates() throws Exception { assertEquals(1.0, FutureValueFactor.calculate(RateAndPeriods.of(0.05,0)).doubleValue(), 0.0d); assertEquals(1.0500, FutureValueFactor.calculate(RateAndPeriods.of(0.05,1)).doubleValue(), 0.0d); assertEquals(1.628894626777441, FutureValueFactor.calculate(RateAndPeriods.of(0.05,10)).doubleValue(), 0.0d); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void calculate_NegativeRates() throws Exception { assertEquals(1.0, FutureValueFactor.calculate(RateAndPeriods.of(-0.05,0)).doubleValue(), 0.0d); assertEquals(0.9500, FutureValueFactor.calculate(RateAndPeriods.of(-0.05,1)).doubleValue(), 0.0d); assertEquals(0.5987369392383789, FutureValueFactor.calculate(RateAndPeriods.of(-0.05,10)).doubleValue(), 0.0d); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void calculate_Invalid(){ assertEquals(1.0, FutureValueFactor.calculate(RateAndPeriods.of(0,0)).doubleValue(), 0.0d); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
FutureValueFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); BigDecimal base = CalculationContext.one().add(rateAndPeriods.getRate().get()); return base.pow(rateAndPeriods.getPeriods(), CalculationContext.mathContext()); } private FutureValueFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void calculate() throws Exception { assertEquals(8.30116383904126, DoublingTimeWithContCompounding.calculate(Rate.of(0.0835)).doubleValue(), 0.0d); assertEquals(1.386294361119891, DoublingTimeWithContCompounding.calculate(Rate.of(0.5)).doubleValue(), 0.0d); assertEquals(0.6931471805599453, DoublingTimeWithContCompounding.calculate(Rate.of(1)).doubleValue(), 0.0d); assertEquals(15.4032706791099, DoublingTimeWithContCompounding.calculate(Rate.of(0.045)).doubleValue(), 0.0d); }
public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); static BigDecimal calculate(Rate rate); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); static BigDecimal calculate(Rate rate); }
@Test(expected = MonetaryException.class) public void calculate_Invalid(){ DoublingTimeWithContCompounding.calculate(Rate.of(0)); }
public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); static BigDecimal calculate(Rate rate); }
DoublingTimeWithContCompounding { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeWithCompounding with a rate=zero"); } return BigDecimal.valueOf(Math.log(2.0d)).divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeWithContCompounding(); static BigDecimal calculate(Rate rate); }
@Test public void of_notNull() throws Exception { BalloonLoanPayment ci = BalloonLoanPayment.of( RateAndPeriods.of(0.05,1), Money.of(5, "CHF") ); assertNotNull(ci); }
public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
@Test public void of_BD() throws Exception { Rate r = Rate.of(BigDecimal.valueOf(0.0567)); assertNotNull(r); }
public static Rate of(BigDecimal rate) { return new Rate(rate, null); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void of_Num() throws Exception { Rate r = Rate.of(0.0567f); assertNotNull(r); }
public static Rate of(BigDecimal rate) { return new Rate(rate, null); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test(expected=NullPointerException.class) public void of_Null() throws Exception { Rate.of((Number)null); }
public static Rate of(BigDecimal rate) { return new Rate(rate, null); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { public static Rate of(BigDecimal rate) { return new Rate(rate, null); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void testHashCode() throws Exception { Rate r1 = Rate.of(0.0567f); Rate r2 = Rate.of(0.0567d); assertTrue(r1.hashCode()==r2.hashCode()); r2 = Rate.of(0.0568d); assertFalse(r1.hashCode()==r2.hashCode()); }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((rate == null) ? 0 : rate.hashCode()); result = prime * result + ((info == null) ? 0 : info.hashCode()); return result; }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((rate == null) ? 0 : rate.hashCode()); result = prime * result + ((info == null) ? 0 : info.hashCode()); return result; } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((rate == null) ? 0 : rate.hashCode()); result = prime * result + ((info == null) ? 0 : info.hashCode()); return result; } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((rate == null) ? 0 : rate.hashCode()); result = prime * result + ((info == null) ? 0 : info.hashCode()); return result; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((rate == null) ? 0 : rate.hashCode()); result = prime * result + ((info == null) ? 0 : info.hashCode()); return result; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void testEquals() throws Exception { Rate r1 = Rate.of(0.0567f); Rate r2 = Rate.of(0.0567d); assertEquals(r1, r2); r2 = Rate.of(0.0568d); assertNotSame(r1, r2); }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rate other = (Rate) obj; if (rate == null) { if (other.rate != null) return false; } else if (!rate.equals(other.rate)) return false; if (info == null) { if (other.info != null) return false; } else if (!info.equals(other.info)) return false; return true; }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rate other = (Rate) obj; if (rate == null) { if (other.rate != null) return false; } else if (!rate.equals(other.rate)) return false; if (info == null) { if (other.info != null) return false; } else if (!info.equals(other.info)) return false; return true; } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rate other = (Rate) obj; if (rate == null) { if (other.rate != null) return false; } else if (!rate.equals(other.rate)) return false; if (info == null) { if (other.info != null) return false; } else if (!info.equals(other.info)) return false; return true; } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rate other = (Rate) obj; if (rate == null) { if (other.rate != null) return false; } else if (!rate.equals(other.rate)) return false; if (info == null) { if (other.info != null) return false; } else if (!info.equals(other.info)) return false; return true; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rate other = (Rate) obj; if (rate == null) { if (other.rate != null) return false; } else if (!rate.equals(other.rate)) return false; if (info == null) { if (other.info != null) return false; } else if (!info.equals(other.info)) return false; return true; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void get() throws Exception { Rate r1 = Rate.of(0.0567f); assertEquals(BigDecimal.valueOf(0.0567d), r1.get()); }
@Override public BigDecimal get() { return this.rate; }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public BigDecimal get() { return this.rate; } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public BigDecimal get() { return this.rate; } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public BigDecimal get() { return this.rate; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public BigDecimal get() { return this.rate; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void testToString() throws Exception { Rate r1 = Rate.of(0.0567f); assertEquals("Rate[0.0567]", r1.toString()); }
@Override public String toString() { if(info!=null){ return "Rate[rate=" + rate + ",info="+info+"]"; } return "Rate[" + rate + "]"; }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public String toString() { if(info!=null){ return "Rate[rate=" + rate + ",info="+info+"]"; } return "Rate[" + rate + "]"; } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public String toString() { if(info!=null){ return "Rate[rate=" + rate + ",info="+info+"]"; } return "Rate[" + rate + "]"; } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public String toString() { if(info!=null){ return "Rate[rate=" + rate + ",info="+info+"]"; } return "Rate[" + rate + "]"; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public String toString() { if(info!=null){ return "Rate[rate=" + rate + ",info="+info+"]"; } return "Rate[" + rate + "]"; } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void apply() throws Exception { Rate r1 = Rate.of(0.05); assertEquals(Money.of(5, "CHF"), r1.apply(Money.of(100, "CHF"))); assertEquals(Money.of(5, "CHF"), Money.of(100, "CHF").with(r1)); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(rate); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(rate); } }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(rate); } private Rate(BigDecimal rate, String info); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(rate); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); }
Rate implements MonetaryOperator, Supplier<BigDecimal> { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(rate); } private Rate(BigDecimal rate, String info); static Rate zero(String info); static Rate of(BigDecimal rate); static Rate of(BigDecimal rate, String info); static Rate of(Number rate); static Rate of(Number rate, String info); @Override int hashCode(); @Override boolean equals(Object obj); @Override BigDecimal get(); String getInfo(); @Override String toString(); @Override MonetaryAmount apply(MonetaryAmount amount); static final Rate ZERO; }
@Test public void getRate() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.03,1) ); assertEquals(val.getRate(), Rate.of(0.03)); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void getPeriods() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.03,3654) ); assertEquals(val.getPeriods(), 3654); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctRate() throws Exception { BalloonLoanPayment ci = BalloonLoanPayment.of( RateAndPeriods.of(0.0234,1), Money.of(5, "CHF") ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.0234)); ci = BalloonLoanPayment.of( RateAndPeriods.of(0.05,1), Money.of(5, "CHF") ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.05)); }
public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
@Test public void of_Period1() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.05, 1) ); assertNotNull(val); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_Period0() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.08,0) ); assertNotNull(val); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods0() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); val = FutureValueOfAnnuity.of( RateAndPeriods.of(-0.05, 0) ); assertEquals(Money.of(0,"CHF"), m.with(val)); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Periods1() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.05, 1) ); assertEquals(Money.of(10,"CHF"), m.with(val)); val = FutureValueOfAnnuity.of( RateAndPeriods.of(-0.05, 1) ); assertEquals(Money.of(10,"CHF"), m.with(val)); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_PeriodsN() throws Exception { Money m = Money.of(10, "CHF"); FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.05, 10) ); assertEquals(Money.of(125.7789253554883,"CHF").getNumber().numberValue(BigDecimal.class) .doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class) .doubleValue(), 0.00000000000001d); val = FutureValueOfAnnuity.of( RateAndPeriods.of(-0.05, 10) ); assertEquals(Money.of(80.25261215232422,"CHF").getNumber().numberValue(BigDecimal.class).doubleValue(), m.with(val).getNumber().numberValue(BigDecimal.class).doubleValue(), 0.000000000000001d); }
public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { public static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods) { return new FutureValueOfAnnuity(rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.08, 10) ); Money m = Money.of(10, "CHF"); assertEquals(val.apply(m), m.with(val)); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void toStringTest() throws Exception { FutureValueOfAnnuity val = FutureValueOfAnnuity.of( RateAndPeriods.of(0.05, 10) ); assertEquals("FutureValueOfAnnuity{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=10}}", val.toString()); }
@Override public String toString() { return "FutureValueOfAnnuity{" + "\n " + rateAndPeriods + '}'; }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuity{" + "\n " + rateAndPeriods + '}'; } }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuity{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuity{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValueOfAnnuity extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValueOfAnnuity{" + "\n " + rateAndPeriods + '}'; } private FutureValueOfAnnuity(RateAndPeriods rateAndPeriods); static FutureValueOfAnnuity of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testOfAndApply() throws Exception { Money money = Money.of(100, "CHF"); MonetaryOperator rounding = Monetary.getRounding(RoundingQueryBuilder.of().setScale(2).set(RoundingMode.HALF_EVEN) .build()); assertEquals(Money.of(BigDecimal.valueOf(105.00), "CHF"), money.with(FutureValue .of(RateAndPeriods.of(0.05, 1))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(110.25), "CHF"), money.with(FutureValue.of(RateAndPeriods.of(0.05, 2))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(210.49), "CHF"), money.with(FutureValue.of(RateAndPeriods.of(0.07, 11))).with(rounding)); }
public static FutureValue of(RateAndPeriods rateAndPeriods) { return new FutureValue(rateAndPeriods); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static FutureValue of(RateAndPeriods rateAndPeriods) { return new FutureValue(rateAndPeriods); } }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static FutureValue of(RateAndPeriods rateAndPeriods) { return new FutureValue(rateAndPeriods); } private FutureValue(RateAndPeriods rateAndPeriods); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static FutureValue of(RateAndPeriods rateAndPeriods) { return new FutureValue(rateAndPeriods); } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static FutureValue of(RateAndPeriods rateAndPeriods) { return new FutureValue(rateAndPeriods); } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testCalculate() throws Exception { Money money = Money.of(100, "CHF"); MonetaryOperator rounding = Monetary.getRounding(RoundingQueryBuilder.of().setScale(2).set(RoundingMode.HALF_EVEN) .build()); assertEquals(Money.of(BigDecimal.valueOf(105.00), "CHF"), FutureValue.calculate(money, RateAndPeriods.of(0.05, 1)).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(110.25), "CHF"), FutureValue.calculate(money, RateAndPeriods.of(0.05, 2)).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(210.49), "CHF"), FutureValue.calculate(money, RateAndPeriods.of(0.07, 11)).with(rounding)); }
public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { BigDecimal f = (CalculationContext.one().add(rateAndPeriods.getRate().get())).pow(rateAndPeriods.getPeriods()); return amount.multiply(f); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { BigDecimal f = (CalculationContext.one().add(rateAndPeriods.getRate().get())).pow(rateAndPeriods.getPeriods()); return amount.multiply(f); } }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { BigDecimal f = (CalculationContext.one().add(rateAndPeriods.getRate().get())).pow(rateAndPeriods.getPeriods()); return amount.multiply(f); } private FutureValue(RateAndPeriods rateAndPeriods); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { BigDecimal f = (CalculationContext.one().add(rateAndPeriods.getRate().get())).pow(rateAndPeriods.getPeriods()); return amount.multiply(f); } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValue extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { BigDecimal f = (CalculationContext.one().add(rateAndPeriods.getRate().get())).pow(rateAndPeriods.getPeriods()); return amount.multiply(f); } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testToString() throws Exception { assertEquals("FutureValue{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=1}}", FutureValue.of(RateAndPeriods.of(0.05, 1)).toString()); assertEquals("FutureValue{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=2}}", FutureValue.of(RateAndPeriods.of(0.05, 2)).toString()); assertEquals("FutureValue{\n" + " RateAndPeriods{\n" + " rate=Rate[0.07]\n" + " periods=11}}", FutureValue.of(RateAndPeriods.of(0.07, 11)).toString()); }
@Override public String toString() { return "FutureValue{" + "\n " + rateAndPeriods + '}'; }
FutureValue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValue{" + "\n " + rateAndPeriods + '}'; } }
FutureValue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValue{" + "\n " + rateAndPeriods + '}'; } private FutureValue(RateAndPeriods rateAndPeriods); }
FutureValue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValue{" + "\n " + rateAndPeriods + '}'; } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
FutureValue extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "FutureValue{" + "\n " + rateAndPeriods + '}'; } private FutureValue(RateAndPeriods rateAndPeriods); static FutureValue of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctPeriods() throws Exception { BalloonLoanPayment ci = BalloonLoanPayment.of( RateAndPeriods.of(0.05,1), Money.of(5, "CHF") ); assertEquals(ci.getPeriods(), 1); ci = BalloonLoanPayment.of( RateAndPeriods.of(0.05,234), Money.of(5, "CHF") ); assertEquals(ci.getPeriods(), 234); }
public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
@Test public void calculate_POSITIVE() throws Exception { assertEquals(99.23871669385536, AverageCollectionPeriod.calculate(BigDecimal.valueOf(3.678)).doubleValue(), 0.0000001d); }
public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_NEGATIVE() throws Exception { assertEquals(-99.23871669385536, AverageCollectionPeriod.calculate(BigDecimal.valueOf(-3.678)).doubleValue(), 0.0000001d); }
public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_Explicit() throws Exception { assertEquals(BigDecimal.valueOf(1042.006525285481), AverageCollectionPeriod.calculate(Money.of(3.678, "CHF"), BigDecimal.valueOf(10.5))); }
public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal calculate(Number receivablesTurnover) { return new BigDecimal(365, CalculationContext.mathContext()) .divide(new BigDecimal(receivablesTurnover.toString()), CalculationContext.mathContext()); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
@Test public void receivableTurnover() throws Exception { assertEquals(BigDecimal.valueOf(2.854812398042414), AverageCollectionPeriod.receivablesTurnover( Money.of(3.678, "CHF"), BigDecimal.valueOf(10.5))); }
public static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable){ return new BigDecimal(avgAccountsReceivable.toString()).divide( revenue.getNumber().numberValue(BigDecimal.class), MathContext.DECIMAL64); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable){ return new BigDecimal(avgAccountsReceivable.toString()).divide( revenue.getNumber().numberValue(BigDecimal.class), MathContext.DECIMAL64); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable){ return new BigDecimal(avgAccountsReceivable.toString()).divide( revenue.getNumber().numberValue(BigDecimal.class), MathContext.DECIMAL64); } }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable){ return new BigDecimal(avgAccountsReceivable.toString()).divide( revenue.getNumber().numberValue(BigDecimal.class), MathContext.DECIMAL64); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
AverageCollectionPeriod implements MonetaryQuery<BigDecimal> { public static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable){ return new BigDecimal(avgAccountsReceivable.toString()).divide( revenue.getNumber().numberValue(BigDecimal.class), MathContext.DECIMAL64); } BigDecimal getAvgAccountsReceivable(); static BigDecimal calculate(Number receivablesTurnover); static BigDecimal receivablesTurnover(MonetaryAmount revenue, Number avgAccountsReceivable); static BigDecimal calculate(MonetaryAmount revenue, Number avgAccountsReceivable); @Override BigDecimal queryFrom(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_POSITIVE() throws Exception { assertEquals(BigDecimal.valueOf(9.411764705882353), RuleOf72.calculate(Rate.of(0.0765))); }
public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); static BigDecimal calculate(Rate input); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); static BigDecimal calculate(Rate input); }
@Test public void calculate_NEGATIVE() throws Exception { assertEquals(BigDecimal.valueOf(-9.411764705882353), RuleOf72.calculate(Rate.of(-0.0765))); }
public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); static BigDecimal calculate(Rate input); }
RuleOf72 { public static BigDecimal calculate(Rate input) { return BD72.divide(input.get().multiply(BigDecimal.valueOf(100)), CalculationContext.mathContext()); } private RuleOf72(); static BigDecimal calculate(Rate input); }
@Test public void calculate() throws Exception { assertEquals(11.72332942555686, DoublingTimeSimple.calculate(Rate.of(0.0853)).doubleValue(), 0.0d); assertEquals(2.0, DoublingTimeSimple.calculate(Rate.of(0.5)).doubleValue(), 0.0d); assertEquals(1.0, DoublingTimeSimple.calculate(Rate.of(1)).doubleValue(), 0.0d); assertEquals(22.22222222222222, DoublingTimeSimple.calculate(Rate.of(0.045)).doubleValue(), 0.0d); }
public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); static BigDecimal calculate(Rate rate); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); static BigDecimal calculate(Rate rate); }
@Test(expected = MonetaryException.class) public void calculate_Invalid(){ DoublingTimeSimple.calculate(Rate.of(0)); }
public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); static BigDecimal calculate(Rate rate); }
DoublingTimeSimple { public static BigDecimal calculate(Rate rate) { if(rate.get().signum()==0){ throw new MonetaryException("Cannot calculate DoublingTimeSimple with a rate=zero"); } return CalculationContext.one(). divide(rate.get(), CalculationContext.mathContext()); } private DoublingTimeSimple(); static BigDecimal calculate(Rate rate); }
@Test public void testOfAndApply() throws Exception { Money money = Money.of(100, "CHF"); MonetaryOperator rounding = Monetary.getRounding(RoundingQueryBuilder.of().setScale(2).set(RoundingMode.HALF_EVEN) .build()); assertEquals(Money.of(BigDecimal.valueOf(95.12), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(0.05, 1))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(90.48), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(0.05, 2))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(46.3), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(0.07, 11))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(100.00), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(0.05, 0))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(100.00), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(-0.05, 0))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(105.13), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(-0.05, 1))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(110.52), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(-0.05, 2))).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(215.98), "CHF"), money.with(PresentValueContinuousCompounding.of(RateAndPeriods.of(-0.07, 11))).with(rounding)); }
public static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods) { return new PresentValueContinuousCompounding(rateAndPeriods); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods) { return new PresentValueContinuousCompounding(rateAndPeriods); } }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods) { return new PresentValueContinuousCompounding(rateAndPeriods); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods) { return new PresentValueContinuousCompounding(rateAndPeriods); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods) { return new PresentValueContinuousCompounding(rateAndPeriods); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testCalculate() throws Exception { Money money = Money.of(100, "CHF"); MonetaryOperator rounding = Monetary.getRounding(RoundingQueryBuilder.of().setScale(2).set(RoundingMode.HALF_EVEN) .build()); assertEquals(Money.of(BigDecimal.valueOf(95.12), "CHF"), PresentValueContinuousCompounding.calculate(money, RateAndPeriods.of(0.05, 1)).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(90.48), "CHF"), PresentValueContinuousCompounding.calculate(money, RateAndPeriods.of(0.05, 2)).with(rounding)); assertEquals(Money.of(BigDecimal.valueOf(46.3), "CHF"), PresentValueContinuousCompounding.calculate(money, RateAndPeriods.of(0.07, 11)).with(rounding)); }
public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { Objects.requireNonNull(amount, "Amount required"); Objects.requireNonNull(rateAndPeriods, "Rate required"); Rate rate = rateAndPeriods.getRate(); int periods = rateAndPeriods.getPeriods(); BigDecimal fact = CalculationContext.one().divide( new BigDecimal(Math.pow(Math.E, rate .get().doubleValue() * periods), CalculationContext.mathContext()), CalculationContext.mathContext()); return amount.multiply(fact); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { Objects.requireNonNull(amount, "Amount required"); Objects.requireNonNull(rateAndPeriods, "Rate required"); Rate rate = rateAndPeriods.getRate(); int periods = rateAndPeriods.getPeriods(); BigDecimal fact = CalculationContext.one().divide( new BigDecimal(Math.pow(Math.E, rate .get().doubleValue() * periods), CalculationContext.mathContext()), CalculationContext.mathContext()); return amount.multiply(fact); } }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { Objects.requireNonNull(amount, "Amount required"); Objects.requireNonNull(rateAndPeriods, "Rate required"); Rate rate = rateAndPeriods.getRate(); int periods = rateAndPeriods.getPeriods(); BigDecimal fact = CalculationContext.one().divide( new BigDecimal(Math.pow(Math.E, rate .get().doubleValue() * periods), CalculationContext.mathContext()), CalculationContext.mathContext()); return amount.multiply(fact); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { Objects.requireNonNull(amount, "Amount required"); Objects.requireNonNull(rateAndPeriods, "Rate required"); Rate rate = rateAndPeriods.getRate(); int periods = rateAndPeriods.getPeriods(); BigDecimal fact = CalculationContext.one().divide( new BigDecimal(Math.pow(Math.E, rate .get().doubleValue() * periods), CalculationContext.mathContext()), CalculationContext.mathContext()); return amount.multiply(fact); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { public static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods) { Objects.requireNonNull(amount, "Amount required"); Objects.requireNonNull(rateAndPeriods, "Rate required"); Rate rate = rateAndPeriods.getRate(); int periods = rateAndPeriods.getPeriods(); BigDecimal fact = CalculationContext.one().divide( new BigDecimal(Math.pow(Math.E, rate .get().doubleValue() * periods), CalculationContext.mathContext()), CalculationContext.mathContext()); return amount.multiply(fact); } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test(expected=MonetaryException.class) public void calculate_zeroPeriods() throws Exception { BalloonLoanPayment.of( RateAndPeriods.of(0.05,0), Money.of(5, "CHF") ); }
public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
@Test public void testToString() throws Exception { assertEquals("PresentValueContinuousCompounding{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=1}}", PresentValueContinuousCompounding.of(RateAndPeriods.of(0.05, 1)).toString()); assertEquals("PresentValueContinuousCompounding{\n" + " RateAndPeriods{\n" + " rate=Rate[0.05]\n" + " periods=2}}", PresentValueContinuousCompounding.of(RateAndPeriods.of(0.05, 2)).toString()); assertEquals("PresentValueContinuousCompounding{\n" + " RateAndPeriods{\n" + " rate=Rate[0.07]\n" + " periods=11}}", PresentValueContinuousCompounding.of(RateAndPeriods.of(0.07, 11)).toString()); }
@Override public String toString() { return "PresentValueContinuousCompounding{" + "\n " + rateAndPeriods + '}'; }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueContinuousCompounding{" + "\n " + rateAndPeriods + '}'; } }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueContinuousCompounding{" + "\n " + rateAndPeriods + '}'; } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueContinuousCompounding{" + "\n " + rateAndPeriods + '}'; } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
PresentValueContinuousCompounding extends AbstractRateAndPeriodBasedOperator { @Override public String toString() { return "PresentValueContinuousCompounding{" + "\n " + rateAndPeriods + '}'; } private PresentValueContinuousCompounding(RateAndPeriods rateAndPeriods); static PresentValueContinuousCompounding of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void ofWeightedValue() throws Exception { WeightedAverage.WeightedValue val = WeightedAverage.ofWeightedValue( new BigDecimal(100.45), new BigDecimal(243) ); assertEquals(val.getValue(), new BigDecimal(100.45)); assertEquals(val.getWeight(), new BigDecimal(243)); }
public static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight){ return new WeightedValue(value, weight); }
WeightedAverage { public static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight){ return new WeightedValue(value, weight); } }
WeightedAverage { public static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight){ return new WeightedValue(value, weight); } private WeightedAverage(Collection<WeightedValue> values); }
WeightedAverage { public static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight){ return new WeightedValue(value, weight); } private WeightedAverage(Collection<WeightedValue> values); static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight); static Builder newBuilder(); Collection<WeightedValue> getValues(); BigDecimal calculateWeightedAverage(); static BigDecimal calculateWeightedAverage(Collection<WeightedValue> values); }
WeightedAverage { public static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight){ return new WeightedValue(value, weight); } private WeightedAverage(Collection<WeightedValue> values); static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight); static Builder newBuilder(); Collection<WeightedValue> getValues(); BigDecimal calculateWeightedAverage(); static BigDecimal calculateWeightedAverage(Collection<WeightedValue> values); }
@Test public void getValues() throws Exception { }
public Collection<WeightedValue> getValues() { return Collections.unmodifiableCollection(values); }
WeightedAverage { public Collection<WeightedValue> getValues() { return Collections.unmodifiableCollection(values); } }
WeightedAverage { public Collection<WeightedValue> getValues() { return Collections.unmodifiableCollection(values); } private WeightedAverage(Collection<WeightedValue> values); }
WeightedAverage { public Collection<WeightedValue> getValues() { return Collections.unmodifiableCollection(values); } private WeightedAverage(Collection<WeightedValue> values); static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight); static Builder newBuilder(); Collection<WeightedValue> getValues(); BigDecimal calculateWeightedAverage(); static BigDecimal calculateWeightedAverage(Collection<WeightedValue> values); }
WeightedAverage { public Collection<WeightedValue> getValues() { return Collections.unmodifiableCollection(values); } private WeightedAverage(Collection<WeightedValue> values); static WeightedValue ofWeightedValue(BigDecimal value, BigDecimal weight); static Builder newBuilder(); Collection<WeightedValue> getValues(); BigDecimal calculateWeightedAverage(); static BigDecimal calculateWeightedAverage(Collection<WeightedValue> values); }
@Test public void calculate_Negative() { assertEquals(1, DiscountFactor.calculate(RateAndPeriods.of(-0.05,0)).doubleValue(), 0.0d); assertEquals(1.0526315789473684, DiscountFactor.calculate(RateAndPeriods.of(-0.05,1)).doubleValue(), 0.0d); assertEquals(1.422382169222759, DiscountFactor.calculate(RateAndPeriods.of(-0.05,10)).doubleValue(), 0.0d); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void calculate_Zero() { assertEquals(1, DiscountFactor.calculate(RateAndPeriods.of(0.00,0)).intValueExact()); assertEquals(1, DiscountFactor.calculate(RateAndPeriods.of(0.00,1)).intValueExact()); assertEquals(1, DiscountFactor.calculate(RateAndPeriods.of(0.00,10)).intValueExact()); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void calculate_Positive() { assertEquals(1.0, DiscountFactor.calculate(RateAndPeriods.of(0.05,0)).doubleValue(), 0.0d); assertEquals(0.95, DiscountFactor.calculate(RateAndPeriods.of(0.05,1)).doubleValue(), 0.0d); assertEquals(0.37110537322255859375, DiscountFactor.calculate(RateAndPeriods.of(0.05,10)).doubleValue(), 0.0d); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test(expected = IllegalArgumentException.class) public void calculate_negativePeriods() { DiscountFactor.calculate(RateAndPeriods.of(-0.05, -1)); }
public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
DiscountFactor { public static BigDecimal calculate(RateAndPeriods rateAndPeriods) { Objects.requireNonNull(rateAndPeriods); final BigDecimal ONE = CalculationContext.one(); BigDecimal div = ONE.min(ONE.add(rateAndPeriods.getRate().get())); BigDecimal factor = ONE.subtract(ONE.add(rateAndPeriods.getRate().get()).pow(rateAndPeriods.getPeriods())) .divide(div, CalculationContext.mathContext()); return ONE.add(factor); } private DiscountFactor(); static BigDecimal calculate(RateAndPeriods rateAndPeriods); }
@Test public void of_notNull() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,1) ); assertNotNull(ci); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctRate() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.0234,1) ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.0234)); ci = SimpleInterest.of( RateAndPeriods.of(0.05,1) ); assertNotNull(ci.getRate()); assertEquals(ci.getRate(), Rate.of(0.05)); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void of_correctPeriods() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,1) ); assertEquals(ci.getPeriods(), 1); ci = SimpleInterest.of( RateAndPeriods.of(0.05,234) ); assertEquals(ci.getPeriods(), 234); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_onePeriods() throws Exception { BalloonLoanPayment ci = BalloonLoanPayment.of( RateAndPeriods.of(0.05,1), Money.of(5, "CHF") ); assertEquals(Money.of(100,"CHF").with(ci).with(Monetary.getDefaultRounding()),Money.of(100,"CHF")); assertEquals(Money.of(0,"CHF").with(ci).with(Monetary.getDefaultRounding()),Money.of(-5,"CHF")); assertEquals(Money.of(-1,"CHF").with(ci).with(Monetary.getDefaultRounding()),Money.of(-6.05,"CHF")); }
public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
BalloonLoanPayment extends AbstractRateAndPeriodBasedOperator { public static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount){ return new BalloonLoanPayment(rateAndPeriods, balloonAmount); } private BalloonLoanPayment(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); MonetaryAmount getBalloonAmount(); static BalloonLoanPayment of(RateAndPeriods rateAndPeriods, MonetaryAmount balloonAmount); @Override MonetaryAmount apply(MonetaryAmount amountPV); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amountPV, MonetaryAmount balloonAmount, RateAndPeriods rateAndPeriods); }
@Test public void calculate_zeroPeriods() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,0) ); assertEquals(Money.of(0,"CHF").with(ci), Money.of(0,"CHF")); assertEquals(Money.of(-100,"CHF").with(ci), Money.of(0,"CHF")); assertEquals(Money.of(100,"CHF").with(ci), Money.of(0,"CHF")); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_onePeriods() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,1) ); assertEquals(Money.of(100,"CHF").with(ci),Money.of(5,"CHF")); assertEquals(Money.of(0,"CHF").with(ci),Money.of(0,"CHF")); assertEquals(Money.of(-100,"CHF").with(ci),Money.of(-5,"CHF")); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void calculate_twoPeriods() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,2) ); assertEquals(Money.of(100,"CHF").with(ci),Money.of(10,"CHF")); assertEquals(Money.of(0,"CHF").with(ci),Money.of(0,"CHF")); assertEquals(Money.of(-100,"CHF").with(ci),Money.of(-10,"CHF")); }
public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { public static SimpleInterest of(RateAndPeriods rateAndPeriods) { return new SimpleInterest(rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void apply() throws Exception { SimpleInterest ci = SimpleInterest.of( RateAndPeriods.of(0.05,7) ); assertEquals(ci.apply(Money.of(100,"CHF")),Money.of(35,"CHF")); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
SimpleInterest extends AbstractRateAndPeriodBasedOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return calculate(amount, rateAndPeriods); } private SimpleInterest(RateAndPeriods rateAndPeriods); static SimpleInterest of(RateAndPeriods rateAndPeriods); static MonetaryAmount calculate(MonetaryAmount amount, RateAndPeriods rateAndPeriods); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); }
@Test public void testOf() { BasisPoint perc = BasisPoint.of(BigDecimal.ONE); assertNotNull(perc); }
public static BasisPoint of(Number number) { return new BasisPoint(number); }
BasisPoint implements MonetaryOperator { public static BasisPoint of(Number number) { return new BasisPoint(number); } }
BasisPoint implements MonetaryOperator { public static BasisPoint of(Number number) { return new BasisPoint(number); } private BasisPoint(final Number decimal); }
BasisPoint implements MonetaryOperator { public static BasisPoint of(Number number) { return new BasisPoint(number); } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }
BasisPoint implements MonetaryOperator { public static BasisPoint of(Number number) { return new BasisPoint(number); } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }
@Test public void testApply() { Money m = Money.of(BigDecimal.valueOf(2.35d), "CHF"); assertEquals(Money.of(BigDecimal.valueOf(0.00235d), "CHF"), BasisPoint.of(BigDecimal.TEN).apply(m)); }
@Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(basisPointValue); }
BasisPoint implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(basisPointValue); } }
BasisPoint implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(basisPointValue); } private BasisPoint(final Number decimal); }
BasisPoint implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(basisPointValue); } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }
BasisPoint implements MonetaryOperator { @Override public MonetaryAmount apply(MonetaryAmount amount) { return amount.multiply(basisPointValue); } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }
@Test public void testToString() { assertEquals("15\u2031", BasisPoint.of(BigDecimal.valueOf(15)) .toString()); }
@Override public String toString() { return NumberFormat.getInstance() .format( basisPointValue.multiply(ONE_TENTHOUSAND, CalculationContext.mathContext())) + "\u2031"; }
BasisPoint implements MonetaryOperator { @Override public String toString() { return NumberFormat.getInstance() .format( basisPointValue.multiply(ONE_TENTHOUSAND, CalculationContext.mathContext())) + "\u2031"; } }
BasisPoint implements MonetaryOperator { @Override public String toString() { return NumberFormat.getInstance() .format( basisPointValue.multiply(ONE_TENTHOUSAND, CalculationContext.mathContext())) + "\u2031"; } private BasisPoint(final Number decimal); }
BasisPoint implements MonetaryOperator { @Override public String toString() { return NumberFormat.getInstance() .format( basisPointValue.multiply(ONE_TENTHOUSAND, CalculationContext.mathContext())) + "\u2031"; } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }
BasisPoint implements MonetaryOperator { @Override public String toString() { return NumberFormat.getInstance() .format( basisPointValue.multiply(ONE_TENTHOUSAND, CalculationContext.mathContext())) + "\u2031"; } private BasisPoint(final Number decimal); static BasisPoint of(Number number); @Override MonetaryAmount apply(MonetaryAmount amount); @Override String toString(); static MonetaryAmount calculate(MonetaryAmount amount, Number basisPoints); }