public virtual void test_resolveValues_dateBased_invalidDateAfter() { ValueStep step = ValueStep.of(date(2014, 4, 3), ValueAdjustment.ofReplace(300d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step)); assertThrowsIllegalArg(() => test.resolveValues(SCHEDULE), "ValueStep date is after the end of the schedule.*"); }
public virtual 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)); }
public virtual void test_resolve_invalid() { ValueStepSequence test = ValueStepSequence.of(date(2016, 4, 20), date(2016, 10, 20), Frequency.P12M, ADJ); ValueStep baseStep = ValueStep.of(date(2016, 1, 20), ValueAdjustment.ofReplace(500d)); assertThrowsIllegalArg(() => test.resolve(ImmutableList.of(baseStep), RollConventions.NONE)); }
public virtual void test_resolveValues_dateBased_invalidChangeValue() { ValueStep step = ValueStep.of(date(2014, 4, 1), ValueAdjustment.ofReplace(300d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step)); assertThrowsIllegalArg(() => test.resolveValues(SCHEDULE), "ValueStep date does not match a period boundary.*"); }
public override Builder set(string propertyName, object newValue) { switch (propertyName.GetHashCode()) { case -1025397910: // firstStepDate this.firstStepDate = (LocalDate)newValue; break; case -292412080: // lastStepDate this.lastStepDate = (LocalDate)newValue; break; case -70023844: // frequency this.frequency = (Frequency)newValue; break; case 1977085293: // adjustment this.adjustment = (ValueAdjustment)newValue; break; default: throw new NoSuchElementException("Unknown property: " + propertyName); } return(this); }
public virtual void test_resolveValues_dateBased_indexZeroValid() { ValueStep step = ValueStep.of(date(2014, 1, 1), ValueAdjustment.ofReplace(300d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step)); assertEquals(test.resolveValues(SCHEDULE), DoubleArray.of(300d, 300d, 300d)); }
public virtual void test_resolveValues_indexBased_duplicateDefinitionInvalid() { ValueStep step1 = ValueStep.of(1, ValueAdjustment.ofReplace(300d)); ValueStep step2 = ValueStep.of(1, ValueAdjustment.ofReplace(400d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step1, step2)); assertThrowsIllegalArg(() => test.resolveValues(SCHEDULE)); }
public virtual void test_resolveValues_indexBased_duplicateDefinitionValid() { ValueStep step1 = ValueStep.of(1, ValueAdjustment.ofReplace(300d)); ValueStep step2 = ValueStep.of(1, ValueAdjustment.ofReplace(300d)); ValueSchedule test = ValueSchedule.of(200d, ImmutableList.of(step1, step2)); assertEquals(test.resolveValues(SCHEDULE), DoubleArray.of(200d, 300d, 300d)); }
public virtual 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 virtual 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)); }
private ValueStep(int?periodIndex, LocalDate date, ValueAdjustment value) { JodaBeanUtils.notNull(value, "value"); this.periodIndex = periodIndex; this.date = date; this.value = value; validate(); }
public virtual void test_NONE() { ValueAdjustment test = ValueAdjustment.NONE; assertEquals(test.ModifyingValue, 0, TOLERANCE); assertEquals(test.Type, ValueAdjustmentType.DELTA_AMOUNT); assertEquals(test.adjust(100), 100, TOLERANCE); assertEquals(test.ToString(), "ValueAdjustment[result = input]"); }
public virtual void test_ofReplace() { ValueAdjustment test = ValueAdjustment.ofReplace(200); assertEquals(test.ModifyingValue, 200, TOLERANCE); assertEquals(test.Type, ValueAdjustmentType.REPLACE); assertEquals(test.adjust(100), 200, TOLERANCE); assertEquals(test.ToString(), "ValueAdjustment[result = 200.0]"); }
public virtual void test_ofDeltaAmount() { ValueAdjustment test = ValueAdjustment.ofDeltaAmount(20); assertEquals(test.ModifyingValue, 20, TOLERANCE); assertEquals(test.Type, ValueAdjustmentType.DELTA_AMOUNT); assertEquals(test.adjust(100), 120, TOLERANCE); assertEquals(test.ToString(), "ValueAdjustment[result = input + 20.0]"); }
public virtual void test_ofMultiplier() { ValueAdjustment test = ValueAdjustment.ofMultiplier(1.1); assertEquals(test.ModifyingValue, 1.1, TOLERANCE); assertEquals(test.Type, ValueAdjustmentType.MULTIPLIER); assertEquals(test.adjust(100), 110, TOLERANCE); assertEquals(test.ToString(), "ValueAdjustment[result = input * 1.1]"); }
public virtual 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)); }
//------------------------------------------------------------------------- public virtual 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); }
private ValueStepSequence(LocalDate firstStepDate, LocalDate lastStepDate, Frequency frequency, ValueAdjustment adjustment) { JodaBeanUtils.notNull(firstStepDate, "firstStepDate"); JodaBeanUtils.notNull(lastStepDate, "lastStepDate"); JodaBeanUtils.notNull(frequency, "frequency"); JodaBeanUtils.notNull(adjustment, "adjustment"); this.firstStepDate = firstStepDate; this.lastStepDate = lastStepDate; this.frequency = frequency; this.adjustment = adjustment; validate(); }
//------------------------------------------------------------------------- public virtual void test_resolve() { ValueStepSequence test = ValueStepSequence.of(date(2016, 4, 20), date(2016, 10, 20), Frequency.P3M, ADJ); ValueStep baseStep = ValueStep.of(date(2016, 1, 20), ValueAdjustment.ofReplace(500d)); IList <ValueStep> steps = test.resolve(ImmutableList.of(baseStep), RollConventions.NONE); assertEquals(steps.Count, 4); assertEquals(steps[0], baseStep); assertEquals(steps[1], ValueStep.of(date(2016, 4, 20), ADJ)); assertEquals(steps[2], ValueStep.of(date(2016, 7, 20), ADJ)); assertEquals(steps[3], ValueStep.of(date(2016, 10, 20), ADJ)); }
//----------------------------------------------------------------------- public override bool Equals(object obj) { if (obj == this) { return(true); } if (obj != null && obj.GetType() == this.GetType()) { ValueAdjustment other = (ValueAdjustment)obj; return(JodaBeanUtils.equal(modifyingValue, other.modifyingValue) && JodaBeanUtils.equal(type, other.type)); } return(false); }
// resolve the steps, broken into a separate method to aid inlining private DoubleArray resolveSteps(IList <SchedulePeriod> periods, RollConvention rollConv) { int size = periods.Count; double[] result = new double[size]; IList <ValueStep> resolvedSteps = StepSequence.map(seq => seq.resolve(steps, rollConv)).orElse(steps); // expand ValueStep to array of adjustments matching the periods // the steps are not sorted, so use fixed size array to absorb incoming data ValueAdjustment[] expandedSteps = new ValueAdjustment[size]; IList <ValueStep> invalidSteps = new List <ValueStep>(); foreach (ValueStep step in resolvedSteps) { int index = step.findIndex(periods); if (index < 0) { invalidSteps.Add(step); continue; } if (expandedSteps[index] != null && !expandedSteps[index].Equals(step.Value)) { throw new System.ArgumentException(Messages.format("Invalid ValueSchedule, two steps resolved to the same schedule period starting on {}, schedule defined as {}", periods[index].UnadjustedStartDate, this)); } expandedSteps[index] = step.Value; } // apply each adjustment double value = initialValue; for (int i = 0; i < size; i++) { if (expandedSteps[i] != null) { value = expandedSteps[i].adjust(value); } result[i] = value; } // ensure that invalid steps cause no changes foreach (ValueStep step in invalidSteps) { double baseValue = result[step.findPreviousIndex(periods)]; double adjusted = step.Value.adjust(baseValue); if (adjusted != baseValue) { throw new System.ArgumentException("ValueStep date does not match a period boundary: " + step.Date.get()); } } // return result return(DoubleArray.ofUnsafe(result)); }
public override Builder set(string propertyName, object newValue) { switch (propertyName.GetHashCode()) { case -980601967: // periodIndex this.periodIndex_Renamed = (int?)newValue; break; case 3076014: // date this.date_Renamed = (LocalDate)newValue; break; case 111972721: // value this.value_Renamed = (ValueAdjustment)newValue; break; default: throw new NoSuchElementException("Unknown property: " + propertyName); } return(this); }
public virtual 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 virtual void test_serialization() { assertSerialization(ValueAdjustment.ofReplace(200)); }
//------------------------------------------------------------------------- public virtual void coverage() { coverImmutableBean(ValueAdjustment.ofReplace(200)); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance that applies at the specified schedule period index. /// <para> /// This factory is used to define the date that the step occurs in relative terms. /// The date is identified by specifying the zero-based index of the schedule period boundary. /// The change will occur at the start of the specified period. /// Thus an index of zero is the start of the first period or initial stub. /// The index must be one or greater, as a change is not permitted at the start of the first period. /// </para> /// <para> /// For example, consider a 5 year swap from 2012-02-01 to 2017-02-01 with 6 month frequency. /// A zero-based index of '2' would refer to start of the 3rd period, which would be 2013-02-01. /// </para> /// <para> /// The value may be absolute or relative, as per <seealso cref="ValueAdjustment"/>. /// /// </para> /// </summary> /// <param name="periodIndex"> the index of the period of the value change </param> /// <param name="value"> the adjustment to make to the value </param> /// <returns> the varying step </returns> public static ValueStep of(int periodIndex, ValueAdjustment value) { return(new ValueStep(periodIndex, null, value)); }
public virtual 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.InitialValue, 10000d, TOLERANCE); assertEquals(test.Steps, ImmutableList.of()); assertEquals(test.StepSequence, seq); }
public virtual 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.InitialValue, 2000d, TOLERANCE); assertEquals(test.Steps, ImmutableList.of(STEP1, STEP2)); assertEquals(test.StepSequence, seq); }
//------------------------------------------------------------------------- public virtual void coverage() { ValueStepSequence seq = ValueStepSequence.of(date(2014, 2, 1), date(2014, 3, 1), Frequency.P1M, ValueAdjustment.ofDeltaAmount(100)); ValueSchedule test = ValueSchedule.of(10000d, Lists.newArrayList(STEP1, STEP2)); coverImmutableBean(test); coverBeanEquals(test, ValueSchedule.of(20000d, seq)); }
//------------------------------------------------------------------------- public virtual void test_resolveValues_sequence() { ValueStepSequence seq = ValueStepSequence.of(date(2014, 2, 1), date(2014, 3, 1), Frequency.P1M, ValueAdjustment.ofDeltaAmount(100)); ValueSchedule test = ValueSchedule.of(200d, seq); assertEquals(test.resolveValues(SCHEDULE), DoubleArray.of(200d, 300d, 400d)); }