public void test_serialization() { assertSerialization(ValueSchedule.of(10000d, Lists.newArrayList(STEP1, STEP2))); }
public void test_of_int() { ValueSchedule test = ValueSchedule.of(10000d); assertEquals(test.getInitialValue(), 10000d, TOLERANCE); assertEquals(test.getSteps(), ImmutableList.of()); }
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)); }
/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(ValueSchedule beanToCopy) { this.initialValue = beanToCopy.getInitialValue(); this.steps = ImmutableList.copyOf(beanToCopy.getSteps()); this.stepSequence = beanToCopy.stepSequence; }
public void equals() { ValueSchedule a1 = ValueSchedule.of(10000d, Lists.newArrayList(STEP1, STEP2)); ValueSchedule a2 = ValueSchedule.of(10000d, Lists.newArrayList(STEP1, STEP2)); ValueSchedule b = ValueSchedule.of(5000d, Lists.newArrayList(STEP1, STEP2)); ValueSchedule c = ValueSchedule.of(10000d, Lists.newArrayList(STEP1)); assertEquals(a1.equals(a2), true); assertEquals(a1.equals(b), false); assertEquals(a1.equals(c), false); }
public void test_resolveValues_indexBased() { ValueStep step1 = ValueStep.of(1, ValueAdjustment.ofReplace(300d)); ValueStep step2 = ValueStep.of(2, ValueAdjustment.ofReplace(400d)); // no steps ValueSchedule test0 = ValueSchedule.of(200d, ImmutableList.of()); assertEquals(test0.resolveValues(SCHEDULE), DoubleArray.of(200d, 200d, 200d)); // step1 ValueSchedule test1a = ValueSchedule.of(200d, ImmutableList.of(step1)); assertEquals(test1a.resolveValues(SCHEDULE), DoubleArray.of(200d, 300d, 300d)); // step2 ValueSchedule test1b = ValueSchedule.of(200d, ImmutableList.of(step2)); assertEquals(test1b.resolveValues(SCHEDULE), DoubleArray.of(200d, 200d, 400d)); // step1 and step2 ValueSchedule test2 = ValueSchedule.of(200d, ImmutableList.of(step1, step2)); assertEquals(test2.resolveValues(SCHEDULE), DoubleArray.of(200d, 300d, 400d)); }
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_builder_validEmpty() { ValueSchedule test = ValueSchedule.builder().build(); assertEquals(test.getInitialValue(), 0d, TOLERANCE); assertEquals(test.getSteps(), ImmutableList.of()); }
private String notional(SwapLeg leg) { if (leg instanceof RateCalculationSwapLeg) { RateCalculationSwapLeg rcLeg = (RateCalculationSwapLeg) leg; NotionalSchedule notionalSchedule = rcLeg.getNotionalSchedule(); ValueSchedule amount = notionalSchedule.getAmount(); double notional = amount.getInitialValue(); String vary = !amount.getSteps().isEmpty() || amount.getStepSequence().isPresent() ? " variable" : ""; Currency currency = notionalSchedule.getFxReset().map(fxr -> fxr.getReferenceCurrency()).orElse(rcLeg.getCurrency()); return SummarizerUtils.amount(currency, notional) + vary; } if (leg instanceof RatePeriodSwapLeg) { RatePeriodSwapLeg rpLeg = (RatePeriodSwapLeg) leg; return SummarizerUtils.amount(rpLeg.getPaymentPeriods().get(0).getNotionalAmount()); } return ""; }
private static SwapTrade parseVariableRates(SwapTrade trade, List<CsvRow> variableRows) { ImmutableList.Builder<ValueStep> stepBuilder = ImmutableList.builder(); for (CsvRow row : variableRows) { LocalDate date = LoaderUtils.parseDate(row.getValue(START_DATE_FIELD)); row.findValue(FIXED_RATE_FIELD) .map(str -> LoaderUtils.parseDoublePercent(str)) .ifPresent(fixedRate -> stepBuilder.add(ValueStep.of(date, ValueAdjustment.ofReplace(fixedRate)))); } ImmutableList<ValueStep> varRates = stepBuilder.build(); if (varRates.isEmpty()) { return trade; } // adjust the trade, inserting the variable rates ImmutableList.Builder<SwapLeg> legBuilder = ImmutableList.builder(); for (SwapLeg swapLeg : trade.getProduct().getLegs()) { RateCalculationSwapLeg leg = (RateCalculationSwapLeg) swapLeg; if (leg.getCalculation() instanceof FixedRateCalculation) { FixedRateCalculation baseCalc = (FixedRateCalculation) leg.getCalculation(); FixedRateCalculation calc = baseCalc.toBuilder() .rate(ValueSchedule.of(baseCalc.getRate().getInitialValue(), varRates)) .build(); legBuilder.add(leg.toBuilder().calculation(calc).build()); } else { legBuilder.add(leg); } } return replaceLegs(trade, legBuilder.build()); }
private void summarizeMainLeg(IborCapFloorLeg mainLeg, StringBuilder buf) { buf.append(mainLeg.getIndex()); buf.append(' '); if (mainLeg.getCapSchedule().isPresent()) { buf.append("Cap "); buf.append(SummarizerUtils.percent(mainLeg.getCapSchedule().get().getInitialValue())); } if (mainLeg.getFloorSchedule().isPresent()) { buf.append("Floor "); buf.append(SummarizerUtils.percent(mainLeg.getFloorSchedule().get().getInitialValue())); } }
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)); }
/** * Resolves the value and adjustments against a specific schedule. * <p> * This converts a schedule into a list of values, one for each schedule period. * * @param schedule the schedule * @return the values, one for each schedule period */ public DoubleArray resolveValues(Schedule schedule) { return resolveValues(schedule.getPeriods(), schedule.getRollConvention()); }
private ValueSchedule parseSchedule(XmlElement scheduleEl, double initialValue, ValueStepSequence seq, FpmlDocument document) { List<XmlElement> stepEls = scheduleEl.getChildren("step"); ImmutableList.Builder<ValueStep> stepBuilder = ImmutableList.builder(); for (XmlElement stepEl : stepEls) { LocalDate stepDate = document.parseDate(stepEl.getChild("stepDate")); double stepValue = document.parseDecimal(stepEl.getChild("stepValue")); stepBuilder.add(ValueStep.of(stepDate, ValueAdjustment.ofReplace(stepValue))); } return ValueSchedule.builder().initialValue(initialValue).steps(stepBuilder.build()).stepSequence(seq).build(); }
private DoubleArray resolveSteps(List<SchedulePeriod> periods, RollConvention rollConv) { int size = periods.size(); double[] result = new double[size]; List<ValueStep> resolvedSteps = getStepSequence().map(seq -> seq.resolve(steps, rollConv)).orElse(steps);
public void test_resolveValues_indexBased_indexTooBig() { ValueStep step = ValueStep.of(3, ValueAdjustment.ofReplace(300d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step)); assertThrowsIllegalArg(() -> test.resolveValues(SCHEDULE)); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case -418368371: // initialValue return ((ValueSchedule) bean).getInitialValue(); case 109761319: // steps return ((ValueSchedule) bean).getSteps(); case 2141410989: // stepSequence return ((ValueSchedule) bean).stepSequence; } return super.propertyGet(bean, propertyName, quiet); }
if (calculation instanceof FixedRateCalculation) { FixedRateCalculation calc = (FixedRateCalculation) calculation; String vary = !calc.getRate().getSteps().isEmpty() || calc.getRate().getStepSequence().isPresent() ? " variable" : ""; return SummarizerUtils.percent(calc.getRate().getInitialValue()) + vary; String gearing = calc.getGearing().map(g -> " * " + SummarizerUtils.value(g.getInitialValue())).orElse(""); String spread = calc.getSpread().map(s -> " + " + SummarizerUtils.percent(s.getInitialValue())).orElse(""); return calc.getIndex().getName() + gearing + spread; OvernightRateCalculation calc = (OvernightRateCalculation) calculation; String avg = calc.getAccrualMethod() == OvernightAccrualMethod.AVERAGED ? " avg" : ""; String gearing = calc.getGearing().map(g -> " * " + SummarizerUtils.value(g.getInitialValue())).orElse(""); String spread = calc.getSpread().map(s -> " + " + SummarizerUtils.percent(s.getInitialValue())).orElse(""); return calc.getIndex().getName() + avg + gearing + spread; String gearing = calc.getGearing().map(g -> " * " + SummarizerUtils.value(g.getInitialValue())).orElse(""); return calc.getIndex().getName() + gearing; KnownAmountSwapLeg kaLeg = (KnownAmountSwapLeg) leg; String vary = !kaLeg.getAmount().getSteps().isEmpty() || kaLeg.getAmount().getStepSequence().isPresent() ? " variable" : ""; return SummarizerUtils.amount(kaLeg.getCurrency(), kaLeg.getAmount().getInitialValue()) + vary;