//populate
public override void Populate()
{
TimeSeries source = Parameters[0].AsTimeSeries;
TimeSeries ds = new TimeSeries(source.DateTimes, false);
ds.Values.AddRange(source.Values);
Int32 rsiPeriod = Parameters[1].AsInt;
Int32 wmaPeriod = Parameters[2].AsInt;
DateTimes = ds.DateTimes;
int period = Math.Max(rsiPeriod, wmaPeriod);
if (period <= 0 || ds.Count == 0)
{
return;
}
var FirstValidValue = Math.Max(rsiPeriod * 3, wmaPeriod);
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
// Clip the raw Put/Call Ratio data
for (int bar = 0; bar < ds.Count; bar++)
{
if (ds[bar] > 0.9)
{
ds[bar] = 0.9;
}
else if (ds[bar] < 0.45)
{
ds[bar] = 0.45;
}
}
// TEMA smoothing
ds = new TEMA_TASC(ds, 5);
// Rainbow smoothing
var rbw = new TimeSeries(DateTimes);
var ma = new WMA(ds, 2);
for (int w = 1; w <= 9; w++)
{
ma = new WMA(ma, 2);
rbw += ma;
}
rbw /= 10d;
rbw = new RSI(rbw, rsiPeriod);
for (int bar = wmaPeriod - 1; bar < ds.Count; bar++)
{
Values[bar] = new WMA(rbw, wmaPeriod)[bar];
}
}
//populate
public override void Populate()
{
BarHistory ds = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
Int32 periodSmooth = Parameters[1].AsInt;
DateTimes = ds.DateTimes;
if (period <= 0 || periodSmooth <= 0 || ds.Count == 0)
{
return;
}
//Assign first bar that contains indicator data
var FirstValidValue = Math.Max(periodSmooth, period);
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
if (ds.Count < 2)
{
return;
}
var _avg = (ds.Open + ds.High + ds.Low + ds.Close) / 4d;
//TODO fill with 0 in the loop
var _haOpen = new TimeSeries(DateTimes);
var _haC = new TimeSeries(DateTimes);
_haOpen[0] = _avg[0];
_haC[0] = _avg[0];
for (int bar = 1; bar < ds.Count; bar++)
{
_haOpen[bar] = (_avg[bar - 1] + _haOpen[bar - 1]) / 2d;
_haC[bar] = (_avg[bar] + _haOpen[bar]
+ Math.Max(ds.High[bar], _haOpen[bar])
+ Math.Min(ds.Low[bar], _haOpen[bar])) / 4d;
}
var TMA1 = new TEMA_TASC(_haC, periodSmooth);
var TMA2 = new TEMA_TASC(TMA1, periodSmooth);
var Diff = TMA1 - TMA2;
var ZLHA = TMA1 + Diff;
var temaZLHA = new TEMA_TASC(ZLHA, periodSmooth);
var _sd = new StdDev(temaZLHA, period);
var _wma = new WMA(temaZLHA, period);
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
Values[bar] = 100 * (temaZLHA[bar] + 2 * _sd[bar] - _wma[bar]) / (4 * _sd[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 FirstValidValue = period * 3;
if (ds == null || ds.Count == 0)
{
return;
}
var R = new TimeSeries(DateTimes);
var SP = new TimeSeries(DateTimes);
for (int bar = 0; bar < ds.Count; bar++)
{
if (bar < period)
{
R[bar] = 0d;
}
else
{
R[bar] = (ds[bar] > ds[bar - 1]) ? 1 : -1;
}
}
var sp = new TEMA_TASC(R, period);
for (int bar = 0; bar < ds.Count; bar++)
{
if (bar >= FirstValidValue)
{
Values[bar] = 100 * (sp[bar] / period);
}
else
{
Values[bar] = 0d;
}
}
}
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];
}
}
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
Double cutoff = Parameters[2].AsDouble;
DateTimes = bars.DateTimes;
if (period <= 0 || DateTimes.Count == 0)
{
return;
}
#region Create Heikin-Ashi series
BarHistory haBars = new BarHistory(bars.Symbol.ToString() + " (Heikin-Ashi)", HistoryScale.Daily);
var HO = bars.Open + 0;
var HH = bars.High + 0;
var HL = bars.Low + 0;
var HC = (bars.Open + bars.High + bars.Low + bars.Close) / 4;
for (int bar = 1; bar < bars.Count; bar++)
{
double o1 = HO[bar - 1];
double c1 = HC[bar - 1];
HO[bar] = (o1 + c1) / 2;
HH[bar] = Math.Max(HO[bar], bars.High[bar]);
HL[bar] = Math.Min(HO[bar], bars.Low[bar]);
haBars.Add(bars.DateTimes[bar], HO[bar], HH[bar], HL[bar], HC[bar], bars.Volume[bar]);
}
#endregion
//Smooth Heikin-Ashi closing price
HC = new TEMA_TASC(HC, Math.Max((int)1, Convert.ToInt32(period / 1.6d)));
//Medium term MA of Volume to limit extremes and division factor
var vave = new SMA(bars.Volume, period * 5) >> 1;
var vmax = vave * 2;
var vc = new TimeSeries(DateTimes);
for (int bar = 0; bar < bars.Count; bar++)
{
if (bars.Volume[bar] < vmax[bar])
{
vc[bar] = bars.Volume[bar];
}
else
{
vc[bar] = vmax[bar];
}
}
//Basic volume trend
var vtr = new TEMA_TASC(new LRSlope(bars.Volume, period), period);
//SVAPO result of price and volume}
var tempSeries = new TimeSeries(DateTimes);
for (int bar = 2; bar < bars.Count; bar++)
{
double temp = 0;
bool hcRising = HC[bar] > (HC[bar - 1] * (1 + cutoff / 1000d));
bool hcDeclining = HC[bar] < (HC[bar - 1] * (1 - cutoff / 1000d));
bool lame2PeriodAlert1 = (vtr[bar] >= vtr[bar - 1]) || (vtr[bar - 1] >= vtr[bar - 2]);
bool lame2PeriodAlert2 = (vtr[bar] > vtr[bar - 1]) || (vtr[bar - 1] > vtr[bar - 2]);
temp = (hcRising && lame2PeriodAlert1) ? vc[bar] :
(hcDeclining && lame2PeriodAlert2) ? -vc[bar] : 0;
tempSeries[bar] = temp;
}
var sumSeries = tempSeries.Sum(period);
var svapo = new TEMA_TASC((sumSeries + vave + 1), period);
for (int bar = period; bar < bars.Count; bar++)
{
Values[bar] = svapo[bar];
}
}
//populate
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
Double CandleSize = Parameters[2].AsDouble;
Int32 setuptimeout = Parameters[3].AsInt;
Int32 ShLTAvg = Parameters[4].AsInt;
DateTimes = bars.DateTimes;
if (period <= 0 || bars.Count == 0)
{
return;
}
var FirstValidValue = Math.Max(ShLTAvg, period);
//base.FirstValidValue = Math.Max(ShLTAvg, period) * 3;
int setup1bar = -1; int setup2bar = -1;
bool keep1 = false; bool keep2 = false; bool keep3 = false;
bool keeping = false; bool keepall = false; int keepallBar = -1;
bool keep1d = false; bool keep2d = false; bool keep3d = false;
bool keepingd = false; bool keepalld = false;
int keepallBard = -1; int keepingdBar = -1; int keepingBar = -1;
bool utr = false; int utrBar = -1; int dtrBar = -1; bool dtr = false;
bool upw = true; bool dnw = true; int lastOccurenceForLTResult = -1;
int i_result = 0; int LTResult = 0; int final_result = 0;
/* Create LT Average */
EMA LTAverage = new EMA(bars.Close, ShLTAvg);
/* Create Heikin-Ashi candles */
var HO = bars.Open + 0;
var HH = bars.High + 0;
var HL = bars.Low + 0;
var HC = (bars.Open + bars.High + bars.Low + bars.Close) / 4;
var haC = HC + 0;
//haC.Description = "Heikin-Ashi Close";
for (int bar = 1; bar < bars.Count; bar++)
{
double o1 = HO[bar - 1];
double c1 = HC[bar - 1];
HO[bar] = (o1 + c1) / 2;
HH[bar] = Math.Max(HO[bar], bars.High[bar]);
HL[bar] = Math.Min(HO[bar], bars.Low[bar]);
haC[bar] = (HC[bar] + HO[bar] + HH[bar] + HL[bar]) / 4;
}
/* Create "Crossover Formula" */
var TMA1 = new TEMA_TASC(haC, period);
var TMA2 = new TEMA_TASC(TMA1, period);
var Diff = TMA1 - TMA2;
var ZlHa = TMA1 + Diff;
var AveragePrice = (bars.High + bars.Low) / 2;
TMA1 = new TEMA_TASC(AveragePrice, period);
TMA2 = new TEMA_TASC(TMA1, period);
Diff = TMA1 - TMA2;
var ZlCl = TMA1 + Diff;
var ZlDif = ZlCl - ZlHa;
//ZlDif.Description = "Crossover formula (" + period + ")";
for (int bar = FirstValidValue; bar < bars.Count; bar++)
{
/* Create green candle */
// Metastock Alert function resource:
// http://www.meta-formula.com/metastock-alert-function.html
//20190228 evaluate the "new condition" on each bar
bool newCondition = (bars.Close[bar] > haC[bar]) || (bars.High[bar] > bars.High[bar - 1] || bars.Low[bar] > bars.Low[bar - 1]);
if (!keep1)
{
if (haC[bar] >= HO[bar] || newCondition)
{
keep1 = true;
setup1bar = bar;
}
}
if (keep1)
{
keep1 = bar + 1 - setup1bar < setuptimeout;
}
keep2 = (ZlDif[bar] >= 0);
//keeping = (keep1 || keep2);
keeping = ((keep1 || newCondition) || keep2); //20190228 "newCondition" should rather be evaluated on each bar
// Save bar when "keeping" is true
if (keeping)
{
keepingBar = bar;
}
else
{
keepingBar = 0;
}
keepall = keeping || (
// Implements Ref(keeping,-1)
((keepingBar > 0) & (bar == keepingBar + 1)) &
(bars.Close[bar] >= bars.Open[bar]) | (bars.Close[bar] >= bars.Close[bar - 1]));
// Save bar when "keepall" is true
if (keepall == true)
{
keepallBar = bar;
}
else
{
keepallBar = 0;
}
keep3 = ((bars.Close - bars.Open).Abs()[bar] < ((bars.High[bar] - bars.Low[bar]) * CandleSize)) &
(bars.High[bar] >= bars.Low[bar - 1]);
utr = keepall ||
// Implements Ref(keepall,-1)
((keepallBar > 0) & (bar == keepallBar + 1) & keep3);
if (utr == true)
{
utrBar = bar;
}
else
{
utrBar = 0;
}
/* Create red candle */
// Metastock Alert function resource:
// http://www.meta-formula.com/metastock-alert-function.html
if (!keep1d)
{
if (haC[bar] < HO[bar])
{
keep1d = true;
setup2bar = bar;
}
}
if (keep1d)
{
keep1d = bar + 1 - setup2bar < setuptimeout;
}
keep2d = (ZlDif[bar] < 0);
keep3d = ((bars.Close - bars.Open).Abs()[bar] < ((bars.High[bar] - bars.Low[bar]) * CandleSize)) &
(bars.Low[bar] <= bars.High[bar - 1]);
keepingd = (keep1d || keep2d);
// Save bar when "keeping" is true
if (keepingd)
{
keepingdBar = bar;
}
else
{
keepingdBar = 0;
}
keepalld = keepingd || (
// Implements Ref(keeping,-1)
((keepingdBar > 0) & (bar == keepingdBar + 1)) &
(bars.Close[bar] < bars.Open[bar]) | (bars.Close[bar] < bars.Close[bar - 1]));
// Save bar when "keepall" is true
if (keepalld == true)
{
keepallBard = bar;
}
else
{
keepallBard = 0;
}
dtr = keepalld ||
// Implements Ref(keepall,-1)
((keepallBard > 0) & ((bar == keepallBard + 1) & keep3d));
if (dtr == true)
{
dtrBar = bar;
}
else
{
dtrBar = 0;
}
upw = !dtr || (((dtrBar > 0) & (bar == dtrBar + 1)) & utr);
dnw = !utr || (((utrBar > 0) & (bar == utrBar + 1)) & dtr);
/* HACOLT */
//ValueWhen
//http://www.meta-formula.com/metastock-valuewhen-function.html
//Result:=If(upw,1, If(dnw,0, ValueWhen(1,upw+dnw,If(upw,1,0))));
if (upw)
{
i_result = 1;
lastOccurenceForLTResult = 1;
}
else
if (dnw)
{
i_result = 0;
lastOccurenceForLTResult = 0;
}
else
{
if (lastOccurenceForLTResult > -1)
{
i_result = lastOccurenceForLTResult;
}
}
bool LTSell = bars.Close[bar] < LTAverage[bar];
LTResult = (i_result == 1) ? 1 : (i_result == 0 && LTSell) ? 0 : LTResult;
final_result = (i_result == 1) ? 100 : (i_result == 0 && LTResult == 1) ? 50 : (i_result == 0 && LTResult == 0) ? 0 : final_result;
Values[bar] = final_result;
}
}
//populate
public override void Populate()
{
BarHistory bars = Parameters[0].AsBarHistory;
Int32 period = Parameters[1].AsInt;
Int32 timeout = Parameters[2].AsInt;
DateTimes = bars.DateTimes;
if (period <= 0 || bars.Count == 0)
{
return;
}
int setup1bar = -1, setup2bar = -1, keepallBar = -1, keepallBard = -1, keepingdBar = -1, keepingBar = -1, utrBar = -1, dtrBar = -1;
bool keep1 = false, keep2 = false, keep3 = false, keeping = false, keepall = false, keep1d = false, keep2d = false, keep3d = false,
keepingd = false, keepalld = false, utr = false, dtr = false, upw = true, dnw = true, result = true;
/* Create Heikin-Ashi candles */
var HO = bars.Open + 0;
var HH = bars.High + 0;
var HL = bars.Low + 0;
var HC = (bars.Open + bars.High + bars.Low + bars.Close) / 4;
var haC = HC + 0;
//haC.Description = "Heikin-Ashi Close";
for (int bar = 1; bar < bars.Count; bar++)
{
double o1 = HO[bar - 1];
double c1 = HC[bar - 1];
HO[bar] = (o1 + c1) / 2;
HH[bar] = Math.Max(HO[bar], bars.High[bar]);
HL[bar] = Math.Min(HO[bar], bars.Low[bar]);
haC[bar] = (HC[bar] + HO[bar] + HH[bar] + HL[bar]) / 4;
}
/* Create "Crossover Formula" */
var TMA1 = new TEMA_TASC(haC, period);
var TMA2 = new TEMA_TASC(TMA1, period);
var Diff = TMA1 - TMA2;
var ZlHa = TMA1 + Diff;
var AveragePrice = (bars.High + bars.Low) / 2;
TMA1 = new TEMA_TASC(AveragePrice, period);
TMA2 = new TEMA_TASC(TMA1, period);
Diff = TMA1 - TMA2;
var ZlCl = TMA1 + Diff;
var ZlDif = ZlCl - ZlHa;
//ZlDif.Description = "Crossover formula (" + period + ")";
for (int bar = period; bar < bars.Count; bar++)
{
/* Create green candle */
// Metastock Alert function resource:
// http://www.meta-formula.com/metastock-alert-function.html
bool newCondition = (bars.Close[bar] > haC[bar]) || (bars.High[bar] > bars.High[bar - 1] || bars.Low[bar] > bars.Low[bar - 1]);
if (!keep1)
{
if (haC[bar] >= HO[bar])
{
keep1 = true;
setup1bar = bar;
}
}
if (keep1)
{
keep1 = bar + 1 - setup1bar < timeout;
}
keep2 = (ZlDif[bar] >= 0);
//keeping = ( keep1 || keep2 );
keeping = ((keep1 || newCondition) || keep2); //20190217 "newCondition" should be evaluated on each bar
// Save bar when "keeping" is true
if (keeping)
{
keepingBar = bar;
}
else
{
keepingBar = 0;
}
keepall = keeping || (
// Implements Ref(keeping,-1)
((keepingBar > 0) & (bar == keepingBar + 1)) &
(bars.Close[bar] >= bars.Open[bar]) | (bars.Close[bar] >= bars.Close[bar - 1]));
// Save bar when "keepall" is true
if (keepall == true)
{
keepallBar = bar;
}
else
{
keepallBar = 0;
}
keep3 = ((bars.Close - bars.Open).Abs()[bar] < ((bars.High[bar] - bars.Low[bar]) * 0.35)) &
(bars.High[bar] >= bars.Low[bar - 1]);
utr = keepall ||
// Implements Ref(keepall,-1)
((keepallBar > 0) & (bar == keepallBar + 1) & keep3);
if (utr == true)
{
utrBar = bar;
}
else
{
utrBar = 0;
}
/* Create red candle */
// Metastock Alert function resource:
// http://www.meta-formula.com/metastock-alert-function.html
if (!keep1d)
{
if (haC[bar] < HO[bar])
{
keep1d = true;
setup2bar = bar;
}
}
if (keep1d)
{
keep1d = bar + 1 - setup2bar < timeout;
}
keep2d = (ZlDif[bar] < 0);
keep3d = ((bars.Close - bars.Open).Abs()[bar] < ((bars.High[bar] - bars.Low[bar]) * 0.35)) &
(bars.Low[bar] <= bars.High[bar - 1]);
keepingd = (keep1d || keep2d);
// Save bar when "keeping" is true
if (keepingd)
{
keepingdBar = bar;
}
else
{
keepingdBar = 0;
}
keepalld = keepingd || (
// Implements Ref(keeping,-1)
((keepingdBar > 0) & (bar == keepingdBar + 1)) &
(bars.Close[bar] < bars.Open[bar]) | (bars.Close[bar] < bars.Close[bar - 1]));
// Save bar when "keepall" is true
if (keepalld == true)
{
keepallBard = bar;
}
else
{
keepallBard = 0;
}
dtr = keepalld ||
// Implements Ref(keepall,-1)
((keepallBard > 0) & ((bar == keepallBard + 1) & keep3d));
if (dtr == true)
{
dtrBar = bar;
}
else
{
dtrBar = 0;
}
upw = !dtr || (((dtrBar > 0) & (bar == dtrBar + 1)) & utr);
dnw = !utr || (((utrBar > 0) & (bar == utrBar + 1)) & dtr);
// Metastock's PREV is statement-based
result = (upw) ? true : (dnw) ? false : result;
/* HACO */
if (result)
{
Values[bar] = 1;
}
else
{
Values[bar] = 0;
}
}
}
