//(BarHistory bars, BarHistory barsFirst, BarHistory barsSecond, int periodRegression, int periodRegressionMomentum,
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 svsiPeriod = Parameters[1].AsInt;
Int32 wmaPeriod = Parameters[2].AsInt;
DateTimes = bars.DateTimes;
var period = Math.Max(svsiPeriod, wmaPeriod);
if (period <= 0 || DateTimes.Count == 0)
{
return;
}
EMA R1 = new EMA(bars.Close, svsiPeriod);
var V2 = new TimeSeries(DateTimes);
var V3 = new TimeSeries(DateTimes);
for (int bar = 0; bar < bars.Count; bar++)
{
V2[bar] = bars.Close[bar] > R1[bar] ? bars.Volume[bar] : 0;
V3[bar] = bars.Close[bar] < R1[bar] ? bars.Volume[bar] : 0;
}
var V4 = new WilderMA(V2, wmaPeriod);
var V5 = new WilderMA(V3, wmaPeriod);
for (int bar = 0; bar < bars.Count; bar++)
{
Values[bar] = V5[bar] == 0 ? 100 : 100 - (100 / (1 + (V4[bar] / V5[bar])));
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 srsiPeriod = Parameters[1].AsInt;
Int32 wmaPeriod = Parameters[2].AsInt;
DateTimes = ds.DateTimes;
var FirstValidValue = Math.Max(srsiPeriod, wmaPeriod);
if (FirstValidValue <= 0 || ds.Count == 0)
{
return;
}
EMA R1 = new EMA(ds, srsiPeriod);
var R2 = new TimeSeries(DateTimes);
var R3 = new TimeSeries(DateTimes);
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
R2[bar] = ds[bar] > R1[bar] ? ds[bar] - R1[bar] : 0;
R3[bar] = ds[bar] < R1[bar] ? R1[bar] - ds[bar] : 0;
}
var R4 = new WilderMA(R2, wmaPeriod);
var R5 = new WilderMA(R3, wmaPeriod);
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
Values[bar] = R5[bar] == 0 ? 100 : 100 - (100 / (1 + (R4[bar] / R5[bar])));
}
}
public void Indicators_WilderMA_test()
{
List <Bar> bars = new List <Bar>();
bars.Add(new Bar(new DateTime(2013, 10, 24, 11, 0, 0), 32066, 32066, 31922, 31931, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 12, 0, 0), 31931, 31970, 31922, 31965, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 13, 0, 0), 31966, 31985, 31958, 31971, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 14, 0, 0), 31972, 31999, 31969, 31979, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 15, 0, 0), 31980, 31982, 31957, 31967, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 16, 0, 0), 31970, 31977, 31961, 31970, 100));
bars.Add(new Bar(new DateTime(2013, 10, 24, 17, 0, 0), 31970, 32000, 31946, 31990, 100));
IEnumerable <double> source = bars.Select(b => b.Close);
IEnumerable <double> result = WilderMA.Values(source, 5);
Assert.AreEqual(7, result.Count());
Assert.AreEqual(0, result.ElementAt(0));
Assert.AreEqual(0, result.ElementAt(1));
Assert.AreEqual(0, result.ElementAt(2));
Assert.AreEqual(0, result.ElementAt(3));
Assert.AreEqual(31962.6, result.ElementAt(4));
Assert.AreEqual(31964.08, Math.Round(result.ElementAt(5), 2));
Assert.AreEqual(31969.264, Math.Round(result.ElementAt(6), 3));
}
//populate
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
DateTimes = bars.DateTimes;
if (period <= 0 || bars.Count == 0)
{
return;
}
TimeSeries LH = bars.High - bars.Low;
TimeSeries HC = (bars.High - (bars.Close >> 1)).Abs();
TimeSeries LC = (bars.Low - (bars.Close >> 1)).Abs();
TimeSeries M = new TimeSeries(DateTimes);
TimeSeries MM = new TimeSeries(DateTimes);
TimeSeries atrs_ = new TimeSeries(DateTimes);
double atr1 = 0, MiD1 = 0, atr2 = 0, MiD2 = 0, atr3 = 0, MiD3 = 0, atrs = 0;
for (int bar = 1; bar < bars.Count; bar++)
{
M[bar] = Math.Max(LH[bar], HC[bar]);
MM[bar] = Math.Max(M[bar], LC[bar]);
atr1 = MM[bar] == HC[bar] ? HC[bar] : 0;
MiD1 = atr1 > 0 ? (bars.Close[bar - 1] + (HC[bar] / 2.0)) : 0.00001;
atr2 = ((MM[bar] == LC[bar]) && atr1 == 0) ? LC[bar] : 0;
MiD2 = atr2 > 0 ? (bars.Low[bar] + (LC[bar] / 2.0)) : 0.00001;
atr3 = ((MM[bar] == LH[bar]) && atr1 == 0 && atr2 == 0) ? LH[bar] : 0;
MiD3 = atr3 > 0 ? (bars.Low[bar] + (LH[bar] / 2.0)) : 0.00001;
atrs = atr1 > 0 ? atr1 / MiD1 :
atr2 > 0 ? atr2 / MiD2 :
atr3 > 0 ? atr3 / MiD3 : 0;
atrs_[bar] = atrs;
}
for (int bar = period + 2; bar < bars.Count; bar++)
{
Values[bar] = new WilderMA(atrs_, 14)[bar] * 100;
}
}
public RMI(DataSeries ds, int len1, int len2, string description)
: base(ds, description)
{
base.FirstValidValue = Math.Max(len1, len2);
if (FirstValidValue < 2)
{
return;
}
if (ds.Count < Math.Max(len1, len2))
{
return;
}
// dansmo version
double u1 = 0;
double d1 = 0;
DataSeries u1Series = new DataSeries(ds, "u1Series(" + ds.Description + "," + len1 + "," + len2 + ")");
DataSeries d1Series = new DataSeries(ds, "d1Series(" + ds.Description + "," + len1 + "," + len2 + ")");
DataSeries ugSeries = new DataSeries(ds, "ugSeries(" + ds.Description + "," + len1 + "," + len2 + ")");
DataSeries dgSeries = new DataSeries(ds, "dgSeries(" + ds.Description + "," + len1 + "," + len2 + ")");
DataSeries rmiSeries = new DataSeries(ds, "rmiSeries(" + ds.Description + "," + len1 + "," + len2 + ")");
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
if (ds[bar] > ds[bar - len1])
{
u1 = ds[bar] - ds[bar - len1];
}
else
{
u1 = 0;
}
if (ds[bar] < ds[bar - len1])
{
d1 = Math.Abs(ds[bar] - ds[bar - len1]);
}
else
{
d1 = 0;
}
u1Series[bar] = u1;
d1Series[bar] = d1;
}
ugSeries = WilderMA.Series(u1Series, len2);
dgSeries = WilderMA.Series(d1Series, len2);
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
base[bar] = 100.0 - (100.0 / (1 + ugSeries[bar] / dgSeries[bar]));
}
// fundtimer's version
/*for (int bar = FirstValidValue; bar < ds.Count; bar++)
* {
* base[bar] = RSI.Series(Momentum.Series(ds, len1), len2)[bar];
* }*/
// dansmo's version, rescaled
/*double u1 = 0;
* double d1 = 0;
* DataSeries u1Series = new DataSeries(ds, "u1Series(" + ds.Description + "," + len1 + "," + len2 +")");
* DataSeries d1Series = new DataSeries(ds, "d1Series(" + ds.Description + "," + len1 + "," + len2 + ")");
* DataSeries ugSeries = new DataSeries(ds, "ugSeries(" + ds.Description + "," + len1 + "," + len2 + ")");
* DataSeries dgSeries = new DataSeries(ds, "dgSeries(" + ds.Description + "," + len1 + "," + len2 + ")");
*
* for (int bar = FirstValidValue; bar < ds.Count; bar++)
* {
* if (ds[bar] > ds[bar - len1])
* u1 = ds[bar] - ds[bar - len1];
* else
* u1 = 0;
*
* if (ds[bar] < ds[bar - len1])
* d1 = Math.Abs(ds[bar] - ds[bar - len1]);
* else
* d1 = 0;
*
* u1Series[bar] = u1;
* d1Series[bar] = d1;
* }
*
* ugSeries = WilderMA.Series(u1Series, len2);
* dgSeries = WilderMA.Series(d1Series, len2);
*
* for (int bar = FirstValidValue; bar < ds.Count; bar++)
* {
* double rm = ugSeries[bar] / dgSeries[bar];
* base[bar] = rm / (1.0 + rm);
* }*/
}
