public override void Populate()
{
BarHistory bars = base.Parameters[0].AsBarHistory;
int period1 = base.Parameters[1].AsInt;
int period2 = base.Parameters[2].AsInt;
this.DateTimes = bars.DateTimes;
int FirstValidValue = Math.Max(period1, period2) + 1;
if (bars.Count < FirstValidValue)
{
return;
}
var MLTP = 2.0 / ((double)period1 + 1.0);
var MLTP2 = (bars.Close - Lowest.Series(bars.Low, period2) - (Highest.Series(bars.High, period2) - bars.Close)).Abs() / (Highest.Series(bars.High, period2) - Lowest.Series(bars.Low, period2));
var timeSeries = MLTP * (1.0 + MLTP2);
for (int i = 0; i < FirstValidValue; i++)
{
base[i] = FastSMA.Series(bars.Close, period1)[i];
}
for (int j = FirstValidValue; j < bars.Count; j++)
{
base.Values[j] = base.Values[j - 1] + timeSeries[j] * (bars.Close[j] - base.Values[j - 1]);
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
Double devs = Parameters[2].AsDouble;
bool Upper = Parameters[3].AsBoolean;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0)
{
return;
}
//Avoid exception errors
if (period < 1 || period > ds.Count)
{
period = ds.Count;
}
int upper = 1;
var ds2 = ds * ds;
var period_sr = Math.Sqrt(period);
var periodM1_sr = Math.Sqrt(period - 1);
var devs2 = devs * devs;
if (!Upper)
{
upper = -1;
}
var _smaSer = new FastSMA(ds, period);
var _sdSer = new StdDev(ds, period);
var _sumK = ds2.Sum(period);
var k1 = devs * Math.Sqrt(period / (period - 1 - devs2));
var k2 = devs * Math.Sqrt((period - 1) / (period - 1 - devs2));
//Assign first bar that contains indicator data
var FirstValidValue = ds.FirstValidIndex + period - 1;
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
double k = _sumK[bar];
k = Math.Sqrt(Math.Max(0d, k - period * _smaSer[bar]));
if (Math.Abs(k / period_sr - _sdSer[bar]) < Math.Abs(k / periodM1_sr - _sdSer[bar]))
{
k = k1;
}
else
{
k = k2;
}
Values[bar] = _smaSer[bar] - upper * k * _sdSer[bar];
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period1 = Parameters[1].AsInt;
Int32 period2 = Parameters[2].AsInt;
DateTimes = ds.DateTimes;
int period = Math.Max(period1, period2);
if (period <= 0 || ds.Count == 0)
{
return;
}
var FirstValidValue = Math.Max(period1, period2);
if (FirstValidValue > ds.Count || FirstValidValue < 0)
{
FirstValidValue = ds.Count;
}
if (ds.Count < Math.Max(period1, period2))
{
return;
}
TASCIndicators.FastSMA ema1 = new FastSMA(ds, period1);
TASCIndicators.FastSMA ema2 = new FastSMA(ds, period2);
for (int bar = 0; bar < ds.Count; bar++)
{
Values[bar] = ema1[bar] - ema2[bar];
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period1 = Parameters[1].AsInt;
Int32 period2 = Parameters[2].AsInt;
DateTimes = ds.DateTimes;
int period = Math.Max(period1, period2);
if (period <= 0 || ds.Count == 0)
{
return;
}
var FirstValidValue = Math.Max(period1, period2);
if (FirstValidValue > ds.Count || FirstValidValue < 0)
{
FirstValidValue = ds.Count;
}
if (ds.Count < Math.Max(period1, period2))
{
return;
}
sMACD smacd = new sMACD(ds, period1, period2);
FastSMA sma = new FastSMA(smacd, 9);
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
Values[bar] = sma[bar];
}
}
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
DateTimes = bars.DateTimes;
if (period <= 0 || DateTimes.Count == 0)
{
return;
}
var FirstValidValue = period;
if (FirstValidValue > bars.Count || FirstValidValue < 0)
{
FirstValidValue = bars.Count;
}
for (int bar = 0; bar < bars.Count; bar++)
{
if (bar >= period)
{
double av = new FastSMA(bars.Volume, period)[bar];
double sd = new StdDev(bars.Volume, period)[bar];
double relVol = (bars.Volume[bar] - av) / sd;
Values[bar] = relVol;
}
else
{
Values[bar] = 0d;
}
}
}
// returns price where sMACD cross 0
private double PsMACDzero(int bar, TimeSeries price, int periodX, int periodY)
{
double result = (periodX * periodY * (FastSMA.Calculate(bar, price, periodX) - FastSMA.Calculate(bar, price, periodY)) +
periodX * price[periodY + 1] -
periodY * price[periodX + 1]) /
(periodX - periodY);
return(result);
}
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 periodK = Parameters[1].AsInt;
Int32 smoothK = Parameters[2].AsInt;
DateTimes = bars.DateTimes;
var period = Math.Max(periodK, smoothK);
if (period <= 0 || DateTimes.Count == 0)
{
return;
}
FastSMA sma = new FastSMA(bars.Close, 2);
TimeSeries sma1 = sma * 5;
TimeSeries sma2 = new FastSMA(sma, 2) * 4;
TimeSeries sma3 = new FastSMA(new FastSMA(sma, 2), 2) * 3;
TimeSeries sma4 = new FastSMA(new FastSMA(new FastSMA(sma, 2), 2), 2) * 2;
TimeSeries sma5 = new FastSMA(new FastSMA(new FastSMA(new FastSMA(sma, 2), 2), 2), 2);
TimeSeries sma6 = new FastSMA(sma5, 2);
TimeSeries sma7 = new FastSMA(sma6, 2);
TimeSeries sma8 = new FastSMA(sma7, 2);
TimeSeries sma9 = new FastSMA(sma8, 2);
TimeSeries sma10 = new FastSMA(sma9, 2);
TimeSeries Rainbow = (sma1 + sma2 + sma3 + sma4 + sma5 + sma6 + sma7 + sma8 + sma9 + sma10) / 20;
TimeSeries RBC = (Rainbow + bars.AveragePriceHLC) / 2;
TimeSeries nom = RBC - new Lowest(bars.Low, periodK);
TimeSeries den = new Highest(bars.High, periodK) - new Lowest(RBC, periodK);
var fastK = new TimeSeries(DateTimes);
for (int bar = 0; bar < bars.Count; bar++)
{
if (bar >= periodK)
{
fastK[bar] = (Math.Min(100, Math.Max(0, 100 * nom[bar] / den[bar])));
}
else
{
fastK[bar] = 0d;
}
}
var K = new FastSMA(fastK, smoothK);
for (int bar = 0; bar < bars.Count; bar++)
{
Values[bar] = K[bar];
}
}
//This static method allows ad-hoc calculation of InstantaneousTrendLine (single calc mode)
public static double Calculate(int bar, TimeSeries ds, int period)
{
if (bar < period + 2 || period > ds.Count)
{
return(0);
}
double smoothedslope = ds[bar] - ds[bar - period + 1]
+ ds[bar - 3] - ds[bar - period + 1 - 3] +
2 * (ds[bar - 1] - ds[bar - period + 1 - 1]
+ ds[bar - 2] - ds[bar - period + 1 - 2]);
return(FastSMA.Calculate(bar, ds, period) + smoothedslope / 12);
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
Boolean useEMA = Parameters[2].AsBoolean;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0 || ds.Count < period)
{
return;
}
var weight = 2d / (period + 1);
TimeSeries sma = FastSMA.Series(ds, period);
TimeSeries ema = EMA.Series(ds, period);
TimeSeries ma = !useEMA ? sma : ema;
double mdev = 0;
var exd = new TimeSeries(DateTimes);
var absDif = (ma - ds).Abs();
var Rate = 2 / (double)(period + 1);
for (int i = 0; i > period; i--)
{
mdev += Math.Abs(ma[i] - ds[i]);
}
mdev /= period;
for (int bar = 1; bar < ds.Count; bar++)
{
if (bar <= period)
{
exd[bar] = mdev;
}
else
{
exd[bar] = absDif[bar] * Rate + exd[bar - 1] * (1.0 - Rate);
}
}
for (int bar = 0; bar < ds.Count; bar++)
{
Values[bar] = exd[bar];
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0)
{
return;
}
var _sd = new StdDev(ds, period);
var _sma = new FastSMA(ds, period);
for (int bar = period; bar < ds.Count; bar++)
{
Values[bar] = 100 * (ds[bar] + 2 * _sd[bar] - _sma[bar]) / (4 * _sd[bar]);
}
}
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 smooth = Parameters[1].AsInt;
Int32 sdPeriod = Parameters[2].AsInt;
DateTimes = bars.DateTimes;
var period = Math.Max(smooth, sdPeriod);
if (period <= 0 || DateTimes.Count == 0 || bars.Count < period)
{
return;
}
FastSMA sma = new FastSMA(bars.Close, 2);
TimeSeries sma1 = sma * 5;
TimeSeries sma2 = new FastSMA(sma, 2) * 4;
TimeSeries sma3 = new FastSMA(new FastSMA(sma, 2), 2) * 3;
TimeSeries sma4 = new FastSMA(new FastSMA(new FastSMA(sma, 2), 2), 2) * 2;
TimeSeries sma5 = new FastSMA(new FastSMA(new FastSMA(new FastSMA(sma, 2), 2), 2), 2);
TimeSeries sma6 = new FastSMA(sma5, 2);
TimeSeries sma7 = new FastSMA(sma6, 2);
TimeSeries sma8 = new FastSMA(sma7, 2);
TimeSeries sma9 = new FastSMA(sma8, 2);
TimeSeries sma10 = new FastSMA(sma9, 2);
TimeSeries Rainbow = (sma1 + sma2 + sma3 + sma4 + sma5 + sma6 + sma7 + sma8 + sma9 + sma10) / 20;
TimeSeries ema1 = new EMA(Rainbow, smooth);
TimeSeries ema2 = new EMA(ema1, smooth);
TimeSeries diff = ema1 - ema2;
TimeSeries ZLRB = ema1 + diff;
TEMA_TASC tema = new TEMA_TASC(ZLRB, smooth);
StdDev sd = new StdDev(tema, sdPeriod);
WMA wma = new WMA(tema, sdPeriod);
var PB = (tema + sd * 2 - wma) / (sd * 4) * 100;
for (int bar = 0; bar < bars.Count; bar++)
{
base[bar] = PB[bar];
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0)
{
return;
}
//Avoid exception errors
if (period < 1 || period > ds.Count)
{
period = ds.Count;
}
var sma = new FastSMA(ds, period);
//Assign first bar that contains indicator data
var FirstValidValue = ds.FirstValidIndex + period + 2;
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
//Initialize start of series with zeroes
//for (int bar = 0; bar < FirstValidValue; bar++)
// Values[bar] = 0;
//Rest of series
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
double smoothedslope = ds[bar] - ds[bar - period + 1]
+ ds[bar - 3] - ds[bar - period + 1 - 3] +
2 * (ds[bar - 1] - ds[bar - period + 1 - 1]
+ ds[bar - 2] - ds[bar - period + 1 - 2]);
Values[bar] = sma[bar] + smoothedslope / 12;
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
Double deviations = Parameters[2].AsDouble;
Boolean useEMA = Parameters[3].AsBoolean;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0 || ds.Count < period)
{
return;
}
TimeSeries sma = FastSMA.Series(ds, period);
TimeSeries ema = EMA.Series(ds, period);
TimeSeries ma = !useEMA ? sma : ema;
ExpDev exd = new ExpDev(ds, period, useEMA);
for (int bar = period; bar < ds.Count; bar++)
{
Values[bar] = ma[bar] - exd[bar] * deviations;
}
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period1 = Parameters[1].AsInt;
Int32 period2 = Parameters[2].AsInt;
Int32 m = Parameters[3].AsInt;
Int32 n = Parameters[4].AsInt;
Int32 c = Parameters[5].AsInt;
Boolean useRMSNoise = Parameters[6].AsBoolean;
DateTimes = ds.DateTimes;
var period = new List <int> {
period1, period2, m, n, c
}.Max();
if (period <= 0 || ds.Count == 0)
{
return;
}
//Assign first bar that contains indicator data
if (n == 0)
{
n = 1;
}
n = Math.Abs(n);
var FirstValidValue = n;
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
if (ds.Count < n || ds == null)
{
return;
}
/* CPC and CPCTrend*/
var lpf1 = new EMA(ds, period1);
var lpf2 = new EMA(ds, period2);
var hCPC = new TimeSeries(DateTimes);
var hTrend = new TimeSeries(DateTimes);
double expnt = 2d / (1 + m);
double cumSum = 0d;
int xBar = 0;
var mom = new Momentum(ds, 1);
hCPC[0] = hTrend[0] = 0d;
for (int bar = 0; bar < ds.Count; bar++)
{
hTrend[bar] = 0d;
}
for (int bar = 1; bar < ds.Count; bar++)
{
if (CrossOver(bar, lpf1, lpf2) || CrossUnder(bar, lpf1, lpf2))
{
cumSum = 0d;
xBar = bar;
}
else
{
cumSum += mom[bar];
}
hCPC[bar] = cumSum;
/* Calculate the Trend with a piecewise EMA */
if (bar - xBar > 0)
{
double diff = expnt * (hCPC[bar] - hTrend[bar - 1]);
hTrend[bar] = hTrend[bar - 1] + diff;
}
}
/* Trend Quality */
TimeSeries hDT = hCPC - hTrend;
TimeSeries hNoise;
if (useRMSNoise)
{
var hDTms = new SMA(hDT * hDT, n);
hNoise = new TimeSeries(DateTimes);
for (int bar = 0; bar < ds.Count; bar++)
{
hNoise[bar] = Math.Sqrt(hDTms[bar]);
}
}
else
{
hNoise = new FastSMA(hDT.Abs(), n);
}
hNoise *= c;
var hQ = hTrend / hNoise;
for (int bar = 0; bar < ds.Count; bar++)
{
Values[bar] = hQ[bar];
}
}
//(BarHistory bars, BarHistory barsFirst, BarHistory barsSecond, int periodRegression, int periodRegressionMomentum,
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
Int32 emaPeriod = Parameters[2].AsInt;
Double cutoffConst = Parameters[3].AsDouble;
Double curtailCoeff = Parameters[4].AsDouble;
DateTimes = bars.DateTimes;
var FirstValidValue = Math.Max(period, emaPeriod) * 3;
if (FirstValidValue > bars.Count || FirstValidValue < 0)
{
FirstValidValue = bars.Count;
}
if (FirstValidValue <= 0 || DateTimes.Count == 0)
{
return;
}
// Based on WL4 coding: http://wl4.wealth-lab.com/cgi-bin/WealthLab.DLL/libraryview?item=245
var dsInter = new TimeSeries(DateTimes);
dsInter[0] = 0d;
// 'Typical' is the AveragePriceC.Series in WLP
for (int bar = 1; bar < bars.Count; bar++)
{
dsInter[bar] = Math.Log(bars.AveragePriceHLC[bar]) - Math.Log(bars.AveragePriceHLC[bar - 1]);
}
// StdDev over 30-day time period (30 bars)
dsInter = new StdDev(dsInter, 30);
var dsCutoff = dsInter * cutoffConst * bars.Close;
// dsAve = Average volume with 1 bar delay
var dsAve = new FastSMA(bars.Volume, period) >> 1;
var dsMax = dsAve * curtailCoeff;
var dsMF = bars.AveragePriceHLC - (bars.AveragePriceHLC >> 1);
var dsSer = new TimeSeries(DateTimes);
var dsVFI = new TimeSeries(DateTimes);
// Optimized summation over period.
double PrevVfi = 0.0;
for (int bar = 0; bar < bars.Count; bar++)
{
double Old = 0.0;
if (bar > period)
{
Old = dsSer[bar - period - 1];
}
double Value = Math.Min(bars.Volume[bar], dsMax[bar]);
double New = 0.0;
if (dsMF[bar] > dsCutoff[bar])
{
New = Value;
}
else if (dsMF[bar] < (-1 * dsCutoff[bar]))
{
New = -1 * Value;
}
dsSer[bar] = New;
dsVFI[bar] = PrevVfi - Old + New;
PrevVfi = dsVFI[bar];
}
dsVFI /= dsAve;
// Smooth VFI and store in result series
var dsEma = new EMA(dsVFI, emaPeriod);
for (int bar = 0; bar < bars.Count; bar++)
{
Values[bar] = dsEma[bar];
}
}
//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;
}
var FirstValidValue = period;
if (FirstValidValue > bars.Count || FirstValidValue < 0)
{
FirstValidValue = bars.Count;
}
var RelVol = new TimeSeries(DateTimes);
if (FirstValidValue > 1)
{
RelVol[FirstValidValue - 1] = 0d;
}
for (int bar = FirstValidValue; bar < bars.Count; bar++)
{
double av = FastSMA.Calculate(bar, bars.Volume, period);
double sd = new StdDev(bars.Volume, period)[bar];
double relVol = (bars.Volume[bar] - av) / sd;
RelVol[bar] = relVol;
}
var aMove = ((bars.Close - (bars.Close >> 1)) / bars.Close >> 1).Abs();
var theMin = new Lowest(aMove, period);
var theMax = new Highest(aMove, period);
var theMove = new TimeSeries(DateTimes);
var theVol = new TimeSeries(DateTimes);
for (int bar = FirstValidValue; bar < bars.Count; bar++)
{
if ((theMax[bar] - theMin[bar]) > 0)
{
theMove[bar] = 1.0 + ((aMove[bar] - theMin[bar]) * (10d - 1d)) / (theMax[bar] - theMin[bar]);
}
}
var theMinV = new Lowest(RelVol, period);
var theMaxV = new Highest(RelVol, period);
for (int bar = FirstValidValue; bar < bars.Count; bar++)
{
if ((theMaxV[bar] - theMinV[bar]) > 0)
{
theVol[bar] = 1.0 + ((RelVol[bar] - theMinV[bar]) * (10d - 1d)) / (theMaxV[bar] - theMinV[bar]);
}
}
var vByM = theVol / theMove;
var avF = new SMA(vByM, period);
var sdF = new StdDev(vByM, period);
var theFoM = (vByM - avF) / sdF;
for (int bar = 0; bar < bars.Count; bar++)
{
Values[bar] = theFoM[bar];
}
}
