/// <summary>
/// Initializes a new instance of the CommodityChannelIndex class
/// </summary>
/// <param name="name">The name of this indicator</param>
/// <param name="period">The period of the standard deviation and moving average (middle band)</param>
/// <param name="movingAverageType">The type of moving average to be used</param>
public CommodityChannelIndex(string name, int period, MovingAverageType movingAverageType = MovingAverageType.Simple)
: base(name)
{
MovingAverageType = movingAverageType;
TypicalPriceAverage = movingAverageType.AsIndicator(name + "_TypicalPriceAvg", period);
TypicalPriceMeanDeviation = new MeanAbsoluteDeviation(name + "_TypicalPriceMAD", period);
}
public override void OnData(Slice slice)
{
Console.WriteLine("log_ondata" + slice.Time.ToString() + " " + slice.FutureChains.Count);
if (!_hasInitialized)
{
foreach (var chain in slice.FutureChains)
{
Console.WriteLine("has chain");
// find the front contract expiring no earlier than in 90 days
var contract = (
from futuresContract in chain.Value.OrderBy(x => x.Expiry)
where futuresContract.Expiry > Time.Date.AddDays(10)
select futuresContract
).FirstOrDefault();
_Symbol = contract.Symbol;
var consolidator = new QuoteBarConsolidator(TimeSpan.FromMinutes(1));
consolidator.DataConsolidated += Consolidator_DataConsolidated;
SubscriptionManager.AddConsolidator(contract.Symbol, consolidator);
_devIndicator = MAD(_Symbol, _fastPeriod, Resolution.Minute);
Log("Added new consolidator for " + _Symbol.Value);
_hasInitialized = true;
}
}
}
public void WarmsUpProperly()
{
var mad = new MeanAbsoluteDeviation(20);
var time = DateTime.Today;
var period = ((IIndicatorWarmUpPeriodProvider)mad).WarmUpPeriod;
for (var i = 0; i < period; i++)
{
mad.Update(time.AddDays(i), i);
Assert.AreEqual(i == period - 1, mad.IsReady);
}
}
public void ResetsProperly()
{
var std = new MeanAbsoluteDeviation(3);
std.Update(DateTime.Today, 1m);
std.Update(DateTime.Today.AddSeconds(1), 2m);
std.Update(DateTime.Today.AddSeconds(1), 1m);
Assert.IsTrue(std.IsReady);
std.Reset();
TestHelper.AssertIndicatorIsInDefaultState(std);
TestHelper.AssertIndicatorIsInDefaultState(std.Mean);
}
public void ResetsProperly()
{
var mad = new MeanAbsoluteDeviation(3);
mad.Update(DateTime.Today, 1d);
mad.Update(DateTime.Today.AddSeconds(1), 2d);
mad.Update(DateTime.Today.AddSeconds(1), 1d);
Assert.IsTrue(mad.IsReady);
mad.Reset();
TestHelper.AssertIndicatorIsInDefaultState(mad);
TestHelper.AssertIndicatorIsInDefaultState(mad.Mean);
}
public void ResetsProperly()
{
var std = new MeanAbsoluteDeviation(3);
std.Update(DateTime.Today, TimeZone.Utc, 1m);
std.Update(DateTime.Today.AddSeconds(1), TimeZone.Utc, 2m);
std.Update(DateTime.Today.AddSeconds(1), TimeZone.Utc, 1m);
Assert.True(std.IsReady);
std.Reset();
TestHelper.AssertIndicatorIsInDefaultState(std);
TestHelper.AssertIndicatorIsInDefaultState(std.Mean);
}
public static (double[], double[]) Calculate(double[] Y, decimal alpha, decimal beta, decimal gamma, int p, int s)
{
WintersHelper.Init(Y, s, alpha, beta, gamma);
(double[], double[])calculated = WintersHelper.Calculate(p, s);
double mad = MeanAbsoluteDeviation.Calculation(Y, calculated.Item1);
if (!double.IsNaN(mad) && mad < SmallestError)
{
SmallestError = mad;
BestAlpha = alpha;
BestBeta = beta;
BestGamma = gamma;
BestResult = calculated;
}
return(calculated);
}
public void ComputesCorrectly()
{
// Indicator output was compared against the octave code:
// mad = @(v) mean(abs(v - mean(v)));
var mad = new MeanAbsoluteDeviation(3);
var reference = DateTime.MinValue;
mad.Update(reference.AddDays(1), 1d);
Assert.AreEqual(0d, mad.Current.Value);
mad.Update(reference.AddDays(2), -1d);
Assert.AreEqual(1d, mad.Current.Value);
mad.Update(reference.AddDays(3), 1d);
Assert.AreEqual(0.888888888888889d, Math.Round(mad.Current.Value, 15));
mad.Update(reference.AddDays(4), -2d);
Assert.AreEqual(1.111111111111111d, Math.Round(mad.Current.Value, 15));
mad.Update(reference.AddDays(5), 3d);
Assert.AreEqual(1.777777777777778d, Math.Round(mad.Current.Value, 15));
}
public void ComputesCorrectly()
{
// Indicator output was compared against the octave code:
// mad = @(v) mean(abs(v - mean(v)));
var std = new MeanAbsoluteDeviation(3);
var reference = DateTime.MinValue;
std.Update(reference.AddDays(1), 1m);
Assert.AreEqual(0m, std.Current.Value);
std.Update(reference.AddDays(2), -1m);
Assert.AreEqual(1m, std.Current.Value);
std.Update(reference.AddDays(3), 1m);
Assert.AreEqual(0.888888888888889m, Decimal.Round(std.Current.Value, 15));
std.Update(reference.AddDays(4), -2m);
Assert.AreEqual(1.111111111111111m, Decimal.Round(std.Current.Value, 15));
std.Update(reference.AddDays(5), 3m);
Assert.AreEqual(1.777777777777778m, Decimal.Round(std.Current.Value, 15));
}
public void ComputesCorrectly()
{
// Indicator output was compared against the octave code:
// mad = @(v) mean(abs(v - mean(v)));
var std = new MeanAbsoluteDeviation(3);
var reference = DateTime.MinValue;
std.Update(reference.AddDays(1), 1m);
Assert.AreEqual(0m, std.Current.Value);
std.Update(reference.AddDays(2), -1m);
Assert.AreEqual(1m, std.Current.Value);
std.Update(reference.AddDays(3), 1m);
Assert.AreEqual(0.888888888888889m, Decimal.Round(std.Current.Value, 15));
std.Update(reference.AddDays(4), -2m);
Assert.AreEqual(1.111111111111111m, Decimal.Round(std.Current.Value, 15));
std.Update(reference.AddDays(5), 3m);
Assert.AreEqual(1.777777777777778m, Decimal.Round(std.Current.Value, 15));
}
public static (double[], double[]) Calculate(
double[] inputValue, int amountOfPeriodsToCalculate, decimal dataSmoothingFactor, decimal trendSmoothingFactor)
{
SmallestError = double.MaxValue;
double initalSmoothedValue = inputValue[0];
(List <double>, List <double>)auxValues = HoltHelper.CalculteSmoothedAndTrendValues(
inputValue.Select(d => (decimal)d).ToList(), dataSmoothingFactor, trendSmoothingFactor, new List <decimal>(), new List <decimal>());
//Calculate forecast for periods which already have real values
double[] full =
HoltHelper.Calculate(auxValues.Item1, auxValues.Item2, inputValue.Take(1).ToList()).ToArray <double>();
(double[], double[])calculated = ArrayBased.Split(full, amountOfPeriodsToCalculate);
double mad = MeanAbsoluteDeviation.Calculation(inputValue, calculated.Item1);
if (!double.IsNaN(mad) && mad < SmallestError)
{
SmallestError = mad;
BestDataSmoothing = (double)dataSmoothingFactor;
BestTrendSmoothing = (double)trendSmoothingFactor;
BestResult = calculated;
}
return(calculated);
}
