public void test_ofDeltaAmount() { ValueAdjustment test = ValueAdjustment.ofDeltaAmount(20); assertEquals(test.getModifyingValue(), 20, TOLERANCE); assertEquals(test.getType(), ValueAdjustmentType.DELTA_AMOUNT); assertEquals(test.adjust(100), 120, TOLERANCE); assertEquals(test.toString(), "ValueAdjustment[result = input + 20.0]"); }
public void test_serialization() { assertSerialization(ValueAdjustment.ofReplace(200)); }
public void equals() { ValueAdjustment a1 = ValueAdjustment.ofReplace(200); ValueAdjustment a2 = ValueAdjustment.ofReplace(200); ValueAdjustment b = ValueAdjustment.ofDeltaMultiplier(200); ValueAdjustment c = ValueAdjustment.ofDeltaMultiplier(0.1); assertEquals(a1.equals(a2), true); assertEquals(a1.equals(b), false); assertEquals(a1.equals(c), false); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 503432553: // modifyingValue return ((ValueAdjustment) bean).getModifyingValue(); case 3575610: // type return ((ValueAdjustment) bean).getType(); } return super.propertyGet(bean, propertyName, quiet); }
public void test_ofDeltaMultiplier() { ValueAdjustment test = ValueAdjustment.ofDeltaMultiplier(0.1); assertEquals(test.getModifyingValue(), 0.1, TOLERANCE); assertEquals(test.getType(), ValueAdjustmentType.DELTA_MULTIPLIER); assertEquals(test.adjust(100), 110, TOLERANCE); assertEquals(test.toString(), "ValueAdjustment[result = input + input * 0.1]"); }
public void test_resolveValues_sequenceAndSteps() { ValueStepSequence seq = ValueStepSequence.of( date(2014, 2, 1), date(2014, 3, 1), Frequency.P1M, ValueAdjustment.ofDeltaAmount(100)); ValueStep step1 = ValueStep.of(date(2014, 1, 1), ValueAdjustment.ofReplace(350d)); ValueSchedule test = ValueSchedule.builder().initialValue(200d).steps(step1).stepSequence(seq).build(); assertEquals(test.resolveValues(SCHEDULE), DoubleArray.of(350d, 450d, 550d)); }
public void test_resolveValues_dateBased_ignoreExcess() { ValueStep step1 = ValueStep.of(date(2014, 2, 1), ValueAdjustment.ofReplace(300d)); ValueStep step2 = ValueStep.of(date(2014, 2, 15), ValueAdjustment.ofReplace(300d)); // no change to value ValueStep step3 = ValueStep.of(date(2014, 3, 1), ValueAdjustment.ofReplace(400d)); ValueStep step4 = ValueStep.of(date(2014, 3, 15), ValueAdjustment.ofDeltaAmount(0d)); // no change to value ValueStep step5 = ValueStep.of(date(2014, 4, 1), ValueAdjustment.ofMultiplier(1d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step1, step2, step3, step4, step5)); assertEquals(test.resolveValues(SCHEDULE), DoubleArray.of(200d, 300d, 400d)); }
@Override public ValueAdjustment toValueAdjustment(double shiftAmount) { return ValueAdjustment.ofDeltaAmount(shiftAmount); }
private ValueStepSequence parseAmountSchedule(XmlElement scheduleEl, double initialValue, FpmlDocument document) { Frequency freq = document.parseFrequency(scheduleEl.getChild("stepFrequency")); LocalDate start = document.parseDate(scheduleEl.getChild("firstNotionalStepDate")); LocalDate end = document.parseDate(scheduleEl.getChild("lastNotionalStepDate")); Optional<XmlElement> amountElOpt = scheduleEl.findChild("notionalStepAmount"); if (amountElOpt.isPresent()) { double amount = document.parseDecimal(amountElOpt.get()); return ValueStepSequence.of(start, end, freq, ValueAdjustment.ofDeltaAmount(amount)); } double rate = document.parseDecimal(scheduleEl.getChild("notionalStepRate")); String relativeTo = scheduleEl.findChild("stepRelativeTo").map(el -> el.getContent()).orElse("Previous"); if (relativeTo.equals("Previous")) { return ValueStepSequence.of(start, end, freq, ValueAdjustment.ofDeltaMultiplier(rate)); } else if (relativeTo.equals("Initial")) { // data model does not support 'relative to initial' but can calculate amount here double amount = initialValue * rate; return ValueStepSequence.of(start, end, freq, ValueAdjustment.ofDeltaAmount(amount)); } else { throw new FpmlParseException(Messages.format( "Unknown 'stepRelativeTo' value '{}', expected 'Initial' or 'Previous'", relativeTo)); } }
continue; if (expandedSteps[index] != null && !expandedSteps[index].equals(step.getValue())) { throw new IllegalArgumentException(Messages.format( "Invalid ValueSchedule, two steps resolved to the same schedule period starting on {}, schedule defined as {}", for (int i = 0; i < size; i++) { if (expandedSteps[i] != null) { value = expandedSteps[i].adjust(value); double adjusted = step.getValue().adjust(baseValue); if (adjusted != baseValue) { throw new IllegalArgumentException("ValueStep date does not match a period boundary: " + step.getDate().get());
@Override public ValueAdjustment toValueAdjustment(double shiftAmount) { return ValueAdjustment.ofDeltaMultiplier(shiftAmount); }
CmsPeriod period2 = CmsPeriod.builder() .currency(EUR) .floorlet(FLOOR.getSteps().get(0).getValue().getModifyingValue()) .notional(-NOTIONAL.getSteps().get(0).getValue().getModifyingValue()) .index(INDEX) .startDate(end1) CmsPeriod period2End = CmsPeriod.builder() .currency(EUR) .floorlet(FLOOR.getSteps().get(0).getValue().getModifyingValue()) .notional(-NOTIONAL.getSteps().get(0).getValue().getModifyingValue()) .index(INDEX) .startDate(end1) CmsPeriod periodCap2 = CmsPeriod.builder() .currency(EUR) .notional(-NOTIONAL.getSteps().get(0).getValue().getModifyingValue()) .index(INDEX) .caplet(CAP.getInitialValue())
@Override public ValueAdjustment toValueAdjustment(double shiftAmount) { return ValueAdjustment.ofMultiplier(shiftAmount); }
@ImmutableValidator private void validate() { ArgChecker.inOrderOrEqual(firstStepDate, lastStepDate, "firstStepDate", "lastStepDate"); ArgChecker.isTrue(adjustment.getType() != ValueAdjustmentType.REPLACE, "ValueAdjustmentType must not be 'Replace'"); }
public void test_resolveValues_sequenceAndStepClash() { ValueStepSequence seq = ValueStepSequence.of( date(2014, 2, 1), date(2014, 3, 1), Frequency.P1M, ValueAdjustment.ofDeltaAmount(100)); ValueStep step1 = ValueStep.of(date(2014, 2, 1), ValueAdjustment.ofReplace(350d)); ValueSchedule test = ValueSchedule.builder().initialValue(200d).steps(step1).stepSequence(seq).build(); assertThrowsIllegalArg(() -> test.resolveValues(SCHEDULE)); }
public void test_of_sequence() { ValueStepSequence seq = ValueStepSequence.of( date(2016, 4, 20), date(2016, 10, 20), Frequency.P3M, ValueAdjustment.ofDeltaAmount(-100)); ValueSchedule test = ValueSchedule.of(10000d, seq); assertEquals(test.getInitialValue(), 10000d, TOLERANCE); assertEquals(test.getSteps(), ImmutableList.of()); assertEquals(test.getStepSequence(), Optional.of(seq)); }
public void test_ofReplace() { ValueAdjustment test = ValueAdjustment.ofReplace(200); assertEquals(test.getModifyingValue(), 200, TOLERANCE); assertEquals(test.getType(), ValueAdjustmentType.REPLACE); assertEquals(test.adjust(100), 200, TOLERANCE); assertEquals(test.toString(), "ValueAdjustment[result = 200.0]"); }
public void coverage() { coverImmutableBean(ValueAdjustment.ofReplace(200)); }
public void test_builder_validFull() { ValueStepSequence seq = ValueStepSequence.of( date(2016, 4, 20), date(2016, 10, 20), Frequency.P3M, ValueAdjustment.ofDeltaAmount(-100)); ValueSchedule test = ValueSchedule.builder() .initialValue(2000d) .steps(STEP1, STEP2) .stepSequence(seq) .build(); assertEquals(test.getInitialValue(), 2000d, TOLERANCE); assertEquals(test.getSteps(), ImmutableList.of(STEP1, STEP2)); assertEquals(test.getStepSequence(), Optional.of(seq)); }