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));
}
