public void ThrowIfMinGreatThanMax(decimal min, decimal max, decimal step)
{
Assert.Throws <ArgumentException>(() =>
{
var param = new OptimizationStepParameter("ema-fast", min, max, step);
});
}
public void PreventZero(decimal step, decimal minStep)
{
Assert.Throws <ArgumentException>(() =>
{
var optimizationParameter = new OptimizationStepParameter("ema-fast", 1, 100, step, minStep);
});
}
public void ThrowIfStepIsNegativeOrZero(double step)
{
Assert.Throws <ArgumentException>(() =>
{
var optimizationParameter = new OptimizationStepParameter("ema-fast", 1, 100, new decimal(step));
});
}
public void StepShouldBeGreatOrEqualThanMinStep(decimal step, decimal minStep)
{
var optimizationParameter = new OptimizationStepParameter("ema-fast", 1, 100, step, minStep);
var actual = Math.Max(Math.Abs(step), Math.Abs(minStep));
Assert.AreEqual(actual, optimizationParameter.Step);
}
public void StepShouldBePositiveAlways(double step)
{
var optimizationParameter = new OptimizationStepParameter("ema-fast", 1, 100, new decimal(step));
Assert.NotNull(optimizationParameter.Step);
Assert.Positive(optimizationParameter.Step.Value);
Assert.AreEqual(optimizationParameter.Step, optimizationParameter.MinStep);
Assert.AreEqual(Math.Abs(step), optimizationParameter.Step);
}
/// <summary>
/// Calculate step and min step values based on default number of fragments
/// </summary>
private void CalculateStep(OptimizationStepParameter parameter, int defaultSegmentAmount)
{
if (defaultSegmentAmount < 1)
{
throw new ArgumentException(nameof(defaultSegmentAmount), $"Number of segments should be positive number, but specified '{defaultSegmentAmount}'");
}
parameter.Step = Math.Abs(parameter.MaxValue - parameter.MinValue) / defaultSegmentAmount;
parameter.MinStep = parameter.Step / 10;
}
public void Estimate1D(decimal min, decimal max, decimal step)
{
var param = new OptimizationStepParameter("ema-fast", min, max, step);
var set = new HashSet <OptimizationParameter>()
{
param
};
_strategy.Initialize(new Target("Profit", new Maximization(), null), new List <Constraint>(), set, new StepBaseOptimizationStrategySettings());
Assert.AreEqual(Math.Floor(Math.Abs(max - min) / Math.Abs(step)) + 1, _strategy.GetTotalBacktestEstimate());
}
public void Serialize(OptimizationStepParameter parameterSet)
{
var json = JsonConvert.SerializeObject(parameterSet);
var optimizationParameter = JsonConvert.DeserializeObject <OptimizationParameter>(json) as OptimizationStepParameter;
Assert.NotNull(optimizationParameter);
Assert.AreEqual(parameterSet.Name, optimizationParameter.Name);
Assert.AreEqual(parameterSet.MinValue, optimizationParameter.MinValue);
Assert.AreEqual(parameterSet.MaxValue, optimizationParameter.MaxValue);
Assert.AreEqual(parameterSet.Step, optimizationParameter.Step);
Assert.AreEqual(parameterSet.MinStep, optimizationParameter.MinStep);
}
public void Enumerate(OptimizationStepParameter optimizationParameter)
{
var enumerator = new OptimizationStepParameterEnumerator(optimizationParameter);
int total = 0;
for (decimal value = optimizationParameter.MinValue; value <= optimizationParameter.MaxValue; value += optimizationParameter.Step.Value)
{
total++;
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(value, enumerator.Current.ToDecimal());
}
Assert.AreEqual(Math.Floor((optimizationParameter.MaxValue - optimizationParameter.MinValue) / optimizationParameter.Step.Value) + 1, total);
Assert.IsFalse(enumerator.MoveNext());
}
public void ThrowIfNoStepProvidedWhenNoSegmentValue()
{
var optimizationParameter = new OptimizationStepParameter("ema-fast", 1, 100);
Assert.Throws <ArgumentException>(() =>
{
_strategy.Initialize(
new Target("Profit", new Maximization(), null),
new List <Constraint>(),
new HashSet <OptimizationParameter> {
optimizationParameter
},
new StepBaseOptimizationStrategySettings());
});
}
public void SerializeCollection(OptimizationStepParameter parameterSet)
{
var json = JsonConvert.SerializeObject(new[] { parameterSet as OptimizationParameter });
var optimizationParameters = JsonConvert.DeserializeObject <List <OptimizationParameter> >(json);
Assert.AreEqual(1, optimizationParameters.Count);
var parsed = optimizationParameters[0] as OptimizationStepParameter;
Assert.NotNull(parsed);
Assert.AreEqual(parameterSet.Name, parsed.Name);
Assert.AreEqual(parameterSet.MinValue, parsed.MinValue);
Assert.AreEqual(parameterSet.MaxValue, parsed.MaxValue);
Assert.AreEqual(parameterSet.Step, parsed.Step);
Assert.AreEqual(parameterSet.MinStep, parsed.MinStep);
}
public void Reduce(int amountOfSegments)
{
var param = new OptimizationStepParameter("ema-fast", 10, 100, 10, 0.1m);
var set = new HashSet <OptimizationParameter> {
param
};
_strategy.Initialize(
new Target("Profit", new Maximization(), null),
new List <Constraint>(),
set,
new StepBaseOptimizationStrategySettings {
DefaultSegmentAmount = amountOfSegments
});
Queue <OptimizationResult> pendingOptimizationResults = new Queue <OptimizationResult>();
int depth = -1;
_strategy.NewParameterSet += (s, parameterSet) =>
{
if (pendingOptimizationResults.Count == 0)
{
depth++;
}
pendingOptimizationResults.Enqueue(new OptimizationResult(_stringify(_profit(parameterSet), _drawdown(parameterSet)), parameterSet, ""));
};
_strategy.PushNewResults(OptimizationResult.Initial);
var step = param.Step ?? 1;
var datapoint = param.MinValue;
while (pendingOptimizationResults.Count > 0)
{
var count = pendingOptimizationResults.Count;
for (int i = 0; i < count; i++)
{
var optimizationResult = pendingOptimizationResults.Dequeue();
Assert.AreEqual(datapoint + step * i,
optimizationResult.ParameterSet.Value["ema-fast"].ToDecimal());
_strategy.PushNewResults(optimizationResult);
}
step = Math.Max(param.MinStep.Value, step / amountOfSegments);
datapoint = param.MaxValue - step * ((decimal)amountOfSegments / 2);
}
}
public void Step1D(decimal min, decimal max, decimal step)
{
var param = new OptimizationStepParameter("ema-fast", min, max, step);
var set = new HashSet <OptimizationParameter>()
{
param
};
_strategy.Initialize(new Target("Profit", new Maximization(), null), new List <Constraint>(), set, new StepBaseOptimizationStrategySettings());
var counter = 0;
using (var enumerator = new EnqueueableEnumerator <ParameterSet>())
{
_strategy.NewParameterSet += (s, parameterSet) =>
{
enumerator.Enqueue(parameterSet);
};
_strategy.PushNewResults(OptimizationResult.Initial);
using (var paramEnumerator = new OptimizationStepParameterEnumerator(param))
{
while (paramEnumerator.MoveNext())
{
var value = paramEnumerator.Current;
counter++;
Assert.IsTrue(enumerator.MoveNext());
var suggestion = enumerator.Current;
Assert.IsNotNull(suggestion);
Assert.IsTrue(suggestion.Value.All(s => set.Any(arg => arg.Name == s.Key)));
Assert.AreEqual(1, suggestion.Value.Count);
Assert.AreEqual(value, suggestion.Value["ema-fast"]);
}
}
Assert.AreEqual(0, enumerator.Count);
}
Assert.Greater(counter, 0);
Assert.AreEqual(Math.Floor((param.MaxValue - param.MinValue) / param.Step.Value) + 1, counter);
}
public void Depth(int _defaultSegmentAmount)
{
var param = new OptimizationStepParameter("ema-fast", 10, 100, 10, 0.1m);
var set = new HashSet <OptimizationParameter> {
param
};
_strategy.Initialize(
new Target("Profit", new Maximization(), null),
new List <Constraint>(),
set,
new StepBaseOptimizationStrategySettings {
DefaultSegmentAmount = _defaultSegmentAmount
});
Queue <OptimizationResult> _pendingOptimizationResults = new Queue <OptimizationResult>();
int depth = -1;
_strategy.NewParameterSet += (s, parameterSet) =>
{
if (_pendingOptimizationResults.Count == 0)
{
depth++;
}
_pendingOptimizationResults.Enqueue(new OptimizationResult(_stringify(_profit(parameterSet), _drawdown(parameterSet)), parameterSet, ""));
};
_strategy.PushNewResults(OptimizationResult.Initial);
while (_pendingOptimizationResults.Count > 0)
{
_strategy.PushNewResults(_pendingOptimizationResults.Dequeue());
}
Assert.AreEqual(Math.Ceiling(Math.Log((double)(param.Step / param.MinStep), _defaultSegmentAmount)), depth);
}
