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()); }