public static DataSeries <Value> VersaceRSI(this DataSeries <Bar> bars, int period)
{
var upAvg = bars.MapElements <Value>((s, v) => s.Pos == 0 ? 0 : Math.Max(s[0].Close - s[1].Close, 0)).EMA(period);
var downAvg = bars.MapElements <Value>((s, v) => s.Pos == 0 ? 0 : Math.Max(s[1].Close - s[0].Close, 0)).EMA(period);
return(upAvg.ZipElements <Value, Value>(downAvg, (u, d, _) => u.Pos == 0 ? 50 : 100 - (100 / (1 + u[0] / d[0]))));
}
public static DataSeries <Value> Weighted(this DataSeries <Bar> bars, double wo, double wl, double wh, double wc)
{
return(bars.MapElements <Value>((s, v) => {
var b = s[0];
return (wo * b.Open + wl * b.Low + wh * b.High + wc * b.Close) / (wo + wl + wh + wc);
}));
}
public static DataSeries <Value> RSquared(this DataSeries <Value> values, int period)
{
return(values.MapElements <Value>((s, v) => {
double sumX = (double)period * (period - 1) * 0.5;
double divisor = sumX * sumX - (double)period * period * (period - 1) * (2 * period - 1) / 6;
double sumXY = 0;
double sumX2 = 0;
double sumY2 = 0;
for (int count = 0; count < period && s.Pos - count >= 0; count++)
{
sumXY += count * s[count];
sumX2 += (count * count);
sumY2 += (s[count] * s[count]);
}
double backBarsSum = s.BackBars(period).Sum(x => x.Val);
double numerator = (period * sumXY - sumX * backBarsSum);
double denominator = (period * sumX2 - (sumX * sumX)) * (period * sumY2 - (backBarsSum * backBarsSum));
if (denominator > 0)
{
return Math.Pow((numerator / Math.Sqrt(denominator)), 2);
}
else
{
return 0;
}
}));
}
public static DataSeries <Value> ReversalIndex(this DataSeries <Bar> bars, int period)
{
return(bars.MapElements <Value>((s, v) =>
s.Pos == 0 ? 0 :
s[0].IsGreen == s[1].IsGreen ? 1 :
-1).EMA(period));
}
public static DataSeries <Value> Reversals2(this DataSeries <Bar> bars, int period, double k)
{
return(bars.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return 0;
}
var totalCount = Math.Min(s.Pos + 1, period);
double reversal = 0;
double continuation = 0;
for (int i = totalCount - 1; i >= 0; i--)
{
if (s[i].IsGreen != s[i + 1].IsGreen)
{
reversal += (double)(totalCount - i) / totalCount;
}
else
{
continuation += (double)(totalCount - i) / totalCount;
}
}
return Math.Max(0, reversal - k * continuation);
}));
}
public static DataSeries <Value> NormalizeUnit(this DataSeries <Value> values)
{
var min = values.Select(x => x.Val).Min();
var max = values.Select(x => x.Val).Max();
var range = max - min;
return(values.MapElements <Value>((s, v) => (s[0] - min) / range));
}
public static DataSeries <Value> DonchianMax(this DataSeries <Bar> bars, int period, double bloatPct = 0)
{
return(bars.MapElements <Value>((s, v) => {
var lookBack = Math.Min(s.Pos + 1, period);
var m = s.BackBars(lookBack).Max(b => b.Max);
var avg = (m + s.BackBars(lookBack).Min(b => b.Min)) / 2;
return avg + (m - avg) * (1 + bloatPct);
}));
}
public static DataSeries <Value> Momentum(this DataSeries <Value> values, int period)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return 0;
}
return s[0] - s[Math.Min(s.Pos, period)];
}));
}
public static DataSeries <Value> MostCommonBarColor(this DataSeries <Bar> bars, int period)
{
return(bars.MapElements <Value>((s, v) => {
var backBars = s.BackBars(Math.Min(s.Pos + 1, period)).ToList();
var groups = backBars.GroupBy(x => x.IsGreen).ToList();
var ordered = groups.OrderByDescending(x => x.Count()).ToList();
var result = ordered.First().Key ? 1 : -1;
return result;
}));
}
public static DataSeries <Value> ChaikinVolatility(this DataSeries <Bar> bars, int period)
{
return(bars
.MapElements <Value>((s, v) => s[0].High - s[0].Low)
.EMA(period)
.MapElements <Value>((s, v) => {
var lookBack = Math.Min(s.Pos, period);
return (s[0] - s[lookBack]) / s[lookBack] * 100;
}));
}
public static DataSeries <Value> EMA(this DataSeries <Value> values, int period)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return s[0];
}
else
{
return s[0] * (2.0 / (1 + period)) + (1 - (2.0 / (1 + period))) * v[1];
}
}));
}
public static DataSeries <Value> ParabolicMA(this DataSeries <Value> values, int period)
{
return(values.MapElements <Value>((s, v) => {
int windowSize = Math.Min(s.Pos + 1, period);
var pValues = s.BackBars(windowSize).ToList();
var sum = 0.0;
for (int i = 0; i < windowSize; i++)
{
sum += Math.Pow((double)(windowSize - i) / windowSize, 2) * pValues[i];
}
return sum / period;
}));
}
public static DataSeries <Value> PercentReturn(this DataSeries <Value> values)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return 0;
}
else
{
return (s[0] - s[1]) / s[1];
}
}));
}
public static DataSeries <Value> BarSum2(this DataSeries <Bar> bars, int period)
{
return(bars.MapElements <Value>((s, v) => {
int windowSize = Math.Min(s.Pos + 1, period);
var pBars = s.BackBars(windowSize).ToList();
var sum = 0.0;
for (int i = 0; i < windowSize; i++)
{
sum += (double)(windowSize - i) / windowSize * (pBars[i].Close - pBars[i].Open);
}
return sum / windowSize;
}));
}
public static DataSeries <Value> Derivative(this DataSeries <Value> values)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return 0;
}
else
{
return s[0] - s[1];
}
}));
}
public static DataSeries <Value> Integral(this DataSeries <Value> values, double c)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return c + s[0];
}
else
{
return s[0] + v[1];
}
}));
}
public static DataSeries <Value> LinReg(this DataSeries <Value> values, int period, int forecast)
{
return(values.MapElements <Value>((s, v) => {
double slope;
double intercept;
int trimmedPeriod = Math.Min(period, s.Pos + 1);
if (trimmedPeriod < 2)
{
return s[0];
}
LinRegInternal(s, trimmedPeriod, out slope, out intercept);
return intercept + slope * (trimmedPeriod - 1 + forecast);
}));
}
public static DataSeries <Value> ATR(this DataSeries <Bar> bars, int period)
{
return(bars.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return s[0].High - s[0].Low;
}
else
{
double trueRange = s[0].High - s[0].Low;
trueRange = Math.Max(Math.Abs(s[0].Low - s[1].Close), Math.Max(trueRange, Math.Abs(s[0].High - s[1].Close)));
return ((Math.Min(s.Pos + 1, period) - 1) * v[1] + trueRange) / Math.Min(s.Pos + 1, period);
}
}));
}
public static DataSeries <Value> Trend(this DataSeries <Bar> bars, int lookback)
{
return(bars.MapElements <Value>((s, v) => {
var windowSize = Math.Min(s.Pos + 1, lookback);
if (windowSize == 0)
{
return s[0].IsGreen ? 1 : -1;
}
else
{
var bb = s.BackBars(windowSize + 1).Skip(1);
return Math.Sign(bb.Count(b => b.IsGreen) - bb.Count(b => b.IsRed));
}
}));
}
public static DataSeries <Value> BarSum1(this DataSeries <Bar> bars, int period)
{
double sum = 0;
return(bars.MapElements <Value>((s, v) => {
if (s.Pos < period)
{
sum += s[0].Close - s[0].Open;
}
else
{
sum = sum - (s[period].Close - s[period].Open) + (s[0].Close - s[0].Open);
}
return sum / period;
}));
}
public static DataSeries <Value> BarSum3(this DataSeries <Bar> bars, int period, int normalizingPeriod, int smoothing)
{
var result = bars.MapElements <Value>((s, v) => {
var normal = s.BackBars(Math.Min(s.Pos + 1, normalizingPeriod)).Max(x => x.WaxHeight());
int windowSize = Math.Min(s.Pos + 1, period);
var pBars = s.BackBars(windowSize).ToList();
var sum = 0.0;
for (int i = 0; i < windowSize; i++)
{
sum += (double)(windowSize - i) / windowSize * (pBars[i].Close - pBars[i].Open) / normal;
}
return(sum / windowSize * 10);
});
return(smoothing > 1 ? result.TriangularMA(smoothing) : result);
}
public static DataSeries <Value> ReversalVolatility(this DataSeries <Bar> bars, int period)
{
return(bars.MapElements <Value>((s, v) => {
var bb = s.BackBars(period).ToList();
bool lastWasGreen = bb.First().IsGreen;
double reversalCount = 0;
for (int i = 1; i < bb.Count; i++)
{
if (bb[i].IsGreen != lastWasGreen)
{
reversalCount += Math.Pow((double)(period - i) / period, 2);
}
lastWasGreen = bb[i].IsGreen;
}
return reversalCount;
}));
}
public static DataSeries <Value> ZLEMA(this DataSeries <Value> barValues, int period)
{
var k = 2.0 / (period + 1);
var oneMinusK = 1 - k;
int lag = (int)Math.Ceiling((period - 1) / 2.0);
return(barValues.MapElements <Value>((s, v) => {
if (s.Pos >= lag)
{
return k * (2 * s[0] - s[lag]) + (oneMinusK * v[1]);
}
else
{
return (double)s[0];
}
}));
}
public static DataSeries <Bar> HeikenAshi(this DataSeries <Bar> bars)
{
return(bars.MapElements <Bar>((s, ha) => {
if (s.Pos == 0)
{
return new Bar(s[0].Timestamp, s[0].Open, s[0].Low, s[0].High, s[0].Close, s[0].Volume);
}
else
{
var haOpen = (ha[1].Open + ha[1].Close) / 2.0;
var haLow = Math.Min(s[0].Low, haOpen);
var haHigh = Math.Max(s[0].High, haOpen);
var haClose = (s[0].Open + s[0].Low + s[0].High + s[0].Close) / 4.0;
return new Bar(s[0].Timestamp, haOpen, haLow, haHigh, haClose, s[0].Volume);
}
}));
}
public static DataSeries <Value> Delay(this DataSeries <Value> values, int delay)
{
DateTime?firstGoodTimestamp = null;
var delayed = values.MapElements <Value>((s, v) => {
if (s.Pos == delay)
{
firstGoodTimestamp = s[0].Timestamp;
}
if (s.Pos < delay)
{
return(new Value(default(DateTime), 0));
}
else
{
var b = s[delay];
return(new Value(default(DateTime), b.Val));
}
});
return(delayed.From(firstGoodTimestamp.Value));
}
public static DataSeries <BiValue> Delay(this DataSeries <BiValue> bars, int delay)
{
DateTime?firstGoodTimestamp = null;
var delayed = bars.MapElements <BiValue>((s, v) => {
if (s.Pos == delay)
{
firstGoodTimestamp = s[0].Timestamp;
}
if (s.Pos < delay)
{
return(new BiValue(0, 0));
}
else
{
var b = s[delay];
return(new BiValue(b.Low, b.High));
}
});
return(delayed.From(firstGoodTimestamp.Value));
}
public static DataSeries <Value> SMA(this DataSeries <Value> values, int period)
{
return(values.MapElements <Value>((s, v) => {
if (s.Pos == 0)
{
return s[0];
}
else
{
int windowSize = Math.Min(s.Pos + 1, period);
var last = v[1] * windowSize;
if (s.Pos >= period)
{
return (last + s[0] - s[period]) / windowSize;
}
else
{
return (last + s[0]) / (windowSize + 1);
}
}
}));
}
static Vec GetIdealOutput(Func <DataSeries <Bar>, double> idealSignal, DataSeries <Bar> predicted)
{
var outputSignal = predicted.MapElements <Value>((s, _) => idealSignal(s));
return(new DenseVector(outputSignal.Skip(1).Select(x => x.Val).ToArray()));
}
public static DataSeries <Value> OpeningWickHeight(this DataSeries <Bar> bars)
{
return(bars.MapElements <Value>((s, v) => s[0].IsGreen ? (s[0].Open - s[0].Low) : (s[0].High - s[0].Open)));
}
public static DataSeries <Value> NormalizeSma10(this DataSeries <Bar> values, Func <Bar, Value> getValue)
{
return(values.MapElements <Value>((s, v) => getValue(s[0])).NormalizeSma10());
}
