public static ValueDatum Momentum(this IBar bar, int period, IEnumerable <IBarDatum> data)
{
double mom = double.MinValue;
double slope = double.MinValue;
double dSlope = double.MinValue;
if (period - data.Count() <= 1)
{
var previousBars = ToSet(data, period - 1);
IBarDatum periodBar = previousBars.Last();
double prevClose = periodBar.Close == double.MinValue ? 0 : periodBar.Close;
mom = bar.Close - prevClose;
IBarDatum previousBar = previousBars.First();
int minutes = (bar.Time - previousBar.Time).Minutes;
double prevMomentum = previousBar.M == double.MinValue ? 0 : previousBar.M;
slope = (mom - prevMomentum) / (double)minutes;
double prevMomDelta = previousBar.DM == double.MinValue ? 0 : previousBar.DM;
dSlope = (slope - prevMomDelta) / (double)minutes;
}
ValueDatum newDatum = new ValueDatum("M", mom, slope, dSlope);
return(newDatum);
}
public void DataCreationTests()
{
List <IBar> upTrendBars = BarMocks.UpMove(5, 100.00);
List <IBarDatum> upTrendBarData = upTrendBars.ToBarDatum().ToList();
var moveAlpha = Move.Open(moves.Count, upTrendBarData.First(), 2)
.Close(upTrendBarData.Last());
Assert.IsNotNull(moveAlpha);
Assert.IsTrue(moveAlpha.TrendType == 2);
IBarDatum startBar = upTrendBarData.First();
IBarDatum endBar = upTrendBarData.Last();
Assert.IsTrue(moveAlpha.Start == startBar);
Assert.IsTrue(moveAlpha.End == endBar);
Assert.IsTrue(moveAlpha.StartIndex == startBar.Index);
Assert.IsTrue(moveAlpha.EndIndex == endBar.Index);
double expectedRange = endBar.High - startBar.Low;
Assert.IsTrue(moveAlpha.Range == expectedRange);
}
public void BarAnalyzerBreakTest()
{
List <IBar> bars = upTrendMocks.ToList();
IBarDatum workingBar = null;
Felix.Data.Trend.TrendType currentTrend = Felix.Data.Trend.TrendType.Unknown;
for (int i = 0, c = bars.Count; i < c; ++i)
{
IBarDatum datum = CreateBar(bars[i]);
BarAnalyzerResult result = BarAnalyzer.Analyze(workingBar, datum, currentTrend);
Felix.Data.Trend.TrendType expectedType = GetExpectedTrendType(datum.Index);
IBarDatum expectedBar = datum.Index != 25 ? datum : workingBar;
VerifyBarAnalyzerResult(result, expectedBar, datum.Index != 25, expectedType);
workingBar = result.WorkingBar;
currentTrend = result.Trend;
}
}
public static IMove Open(int id, IBarDatum data, int trendType)
{
var move = new Move {
MoveId = id, Start = data, TrendType = trendType
};
return(move);
}
private static Trend.TrendType GetBarTrend(IBarDatum bar)
{
bool bUp = bar.Close > bar.Open;
bool bDown = bar.Close < bar.Open;
return(bUp ? Trend.TrendType.Up : bDown?Trend.TrendType.Down : Trend.TrendType.Unknown);
}
private IBarDatum GetRetraceBar()
{
IBarDatum barDatum = ChildWaves.Where(w => w.Trend != Trend && w.EndBar != null)
.Select(w => w.EndBar)
.FirstOrDefault();
return(barDatum);
}
public void Insert(IBarDatum bd)
{
InsertDataList(bd);
BarAnalyzerResult result = BarAnalyzer.Analyze(WorkingBar, bd, CurrentTrendType);
Update(result);
}
private void VerifyBarAnalyzerResult(BarAnalyzerResult result, IBarDatum expectedBar, bool expectedValidity, Felix.Data.Trend.TrendType expectedTrend)
{
Assert.IsNotNull(result);
Assert.IsTrue(result.Trend == expectedTrend);
Assert.IsTrue(result.WorkingBar == expectedBar);
Assert.IsTrue(result.IsValidTrendBar == expectedValidity);
}
public IMoveAnalyzerResult Execute(IMoveManager moveMgr, IMove newMove)
{
IBarDatum barData = newMove.Start;
List <ProspectiveIR> gamma = GammaAnalyzer.GetValues(false, barData); //gamma
var irList = moveMgr.Highs
.Where(b => b.High < barData.Low)
.Select(h => h.High)
.Distinct()
.OrderBy(v => v)
.ToList();
var irLowPoints = moveMgr.Lows
.Where(b => b.Low < barData.Low)
.Select(l => l.Low)
.Distinct()
.OrderBy(v => v)
.ToList();
irList.AddRange(irLowPoints.Where(v => !irList.Contains(v)).ToList());
var tempList = new List <double>();
if (barData.Low > moveMgr.PreviousMove.Start.High)
{
List <double> APrevious = AFromBar(moveMgr.PreviousMove.Start);
foreach (var a in APrevious)
{
var possibles = irList.Where(v => Math.Abs(a - v) < 5).ToList();
tempList.AddRange(possibles);
}
}
else
{
tempList = irList;
}
List <ProspectiveIR> resultList = new List <ProspectiveIR>();
foreach (var g in gamma)
{
var possible = tempList.Where(t => Math.Abs(g.Price - t) < 5).ToList().Min();
resultList.Add(new ProspectiveIR(g.Degrees, possible));
}
MoveAnalyzerResult result = new MoveAnalyzerResult(barData, resultList);
return(result);
}
public void BarStreamTest()
{
IBarDatum datum = CreateFirstBar();
barDatumEntries.Add(datum);
Assert.IsTrue(barDatumEntries.Count == 1);
moveManager.Insert(datum);
moveManager.BarStream.Subscribe(b => BarIsValid(b));
}
private void TransitionToUpFromDown(BarAnalyzerResult result)
{
// Get Highest high
IBarDatum lowest = DataList
.Where(e => e.Index >= WorkingBar.Index && e.Index <= result.WorkingBar.Index)
.OrderBy(e => e.Low)
.First();
LowList.Add(lowest);
Transition(result, lowest);
}
private void TransitionToDownFromUp(BarAnalyzerResult result)
{
// get lowest low
IBarDatum highest = DataList
.Where(e => e.Index >= WorkingBar.Index && e.Index <= result.WorkingBar.Index)
.OrderByDescending(e => e.High)
.First();
HighList.Add(highest);
Transition(result, highest);
}
private void Transition(BarAnalyzerResult result, IBarDatum datum)
{
IMove prevMove = CurrentMove.Close(datum);
var newMove = Move.Open(MoveList.Count, datum, (int)result.Trend);
MoveList.Add(newMove);
CurrentTrendType = result.Trend;
MoveSubject.OnNext(prevMove);
}
public void MoveStreamTest()
{
moveManager.MoveStream.Subscribe(m => ValidateMoveStream(m));
foreach (IBar bar in upTrendMocks)
{
IBarDatum datum = CreateBar(bar);
barDatumEntries.Add(datum);
moveManager.Insert(datum);
}
Assert.IsTrue(moves.Count > 0);
}
public IMove Close(IBarDatum data)
{
End = data;
if (TrendType == (int)Trend.TrendType.Down)
{
Range = Start.High - End.Low;
}
else if (TrendType == (int)Trend.TrendType.Up)
{
Range = End.High - Start.Low;
}
return(this);
}
public void BarAnalyzerInitialTest()
{
IBar bar = upTrendMocks.First();
IBarDatum datum = CreateBar(bar);
BarAnalyzerResult result = BarAnalyzer.Analyze(null, datum, Felix.Data.Trend.TrendType.Unknown);
Assert.IsNotNull(result);
Assert.IsTrue(result.Trend == Felix.Data.Trend.TrendType.Up);
Assert.IsTrue(result.WorkingBar == datum);
Assert.IsTrue(result.IsValidTrendBar == true);
}
public void BarAnalyzerTest()
{
List <IBar> bars = upTrendMocks.Take(5).ToList();
IBarDatum workingBar = null;
foreach (IBar bar in bars)
{
IBarDatum datum = CreateBar(bar);
BarAnalyzerResult result = BarAnalyzer.Analyze(workingBar, datum, Felix.Data.Trend.TrendType.Unknown);
VerifyBarAnalyzerResult(result, datum, true, Felix.Data.Trend.TrendType.Up);
workingBar = result.WorkingBar;
}
}
protected List <double> AFromBar(IBarDatum data)
{
if (data == null)
{
Debugger.Break();
}
var irs = new List <double>()
{
data.A0,
data.A1,
data.A2,
data.A3,
data.A4
};
return(irs);
}
public static double GetMultiplier(bool uptrend, IBarDatum data)
{
double value = double.MinValue;
switch (data.ContractId)
{
case 1: // actually the value we're looking for is in the marketId
value = uptrend ? data.Low : data.High;
break;
}
if (value == double.MinValue)
{
throw new Exception($"GammaAnalyzer Multiplier Error");
}
return(value);
}
public static ValueDatum Sma(this IBar bar, IMetaMapping mapping, IEnumerable <IBarDatum> data)
{
int period = mapping.Value.Value;
double ave = double.MinValue;
double slope = double.MinValue;
double dSlope = double.MinValue;
var previousBars = ToSet(data, period - 1);
if (period - previousBars.Count <= 1)
{
ave = (previousBars.Sum(b => b.Close) + bar.Close) / (double)period;
IBarDatum previousBar = previousBars[0];
int minutes = (bar.Time - previousBar.Time).Minutes;
double prevAve = (double)Properties.Where(p => p.Name == mapping.Property)
.First()
.GetValue(previousBar, null);
prevAve = prevAve == double.MinValue ? 0 : prevAve;
slope = (ave - prevAve) / (double)minutes;
double prevSlope = (double)Properties.Where(p => p.Name == $"D{mapping.Property}")
.First()
.GetValue(previousBar, null);
prevSlope = prevSlope == double.MinValue ? 0 : prevSlope;
dSlope = (slope - prevSlope) / (double)minutes;
}
ValueDatum newDatum = new ValueDatum(mapping.Property, ave, slope, dSlope);
return(newDatum);
}
public static List <ProspectiveIR> GetValues(bool upTrend, IBarDatum data)
{
double baseValue = GetMultiplier(upTrend, data);
double baseGamma = Math.Sqrt(baseValue);
List <ProspectiveIR> values = new List <ProspectiveIR>();
for (int i = 0; i < 11; ++i)
{
double deg = 30.00 + i * 15.00;
double gd = deg / 180;
double value = upTrend ? Math.Pow(baseGamma + gd, 2) : Math.Pow(baseGamma - gd, 2);
values.Add(new ProspectiveIR(deg, value));
}
return(values);
}
private double GetCharacteristic()
{
double dSlope = double.MinValue;
IBarDatum retrace = GetRetraceBar();
if (retrace != null)
{
double dMinutes = (double)(retrace.Time - StartBar.Time).Minutes;
if (Trend == (int)Data.Trend.TrendType.Up)
{
dSlope = (retrace.Low - StartBar.Low) / dMinutes;
}
else
{
dSlope = (retrace.High - StartBar.High) / dMinutes;
}
}
return(dSlope);
}
public void WaveTest()
{
InitializeMoves();
IBarDatum lastTrendBar = moves.Last().End;
List <IBar> testBar = BarMocks.DownMove(1, lastTrendBar.High - 5);
List <IBarDatum> testDatum = testBar.ToBarDatum().ToList();
bars.ForEach(b => moveManager.Insert(b));
var ir = moveManager.Highs.Where(b => b.High < testDatum.First().Low)
.Select(b => b.High).ToList();
var lowBarQuery = moveManager.Lows.Where(b => b.Low < testDatum.First().Low)
.Select(b => b.Low).ToList();
ir.AddRange(lowBarQuery);
Assert.IsTrue(ir.Count == 2);
}
private void InitializeMoves()
{
List <IBar> upTrendBars = BarMocks.UpMove(5, 100.00);
List <IBarDatum> upTrendBarData = upTrendBars.ToBarDatum().ToList();
bars.AddRange(upTrendBarData);
var moveAlpha = Move.Open(moves.Count, upTrendBarData.First(), 2)
.Close(upTrendBarData.Last());
moves.Add(moveAlpha);
IBarDatum last = moveAlpha.End;
List <IBar> downTrend = BarMocks.DownMove(3, last.High - 10);
List <IBarDatum> downData = downTrend.ToBarDatum().ToList();
bars.AddRange(downData);
var moveBeta = Move.Open(moves.Count, downData.First(), 3)
.Close(downData.Last());
moves.Add(moveBeta);
last = moveBeta.End;
upTrendBars = BarMocks.UpMove(5, last.Low + 10);
upTrendBarData = upTrendBars.ToBarDatum().ToList();
bars.AddRange(upTrendBarData);
var moveGamma = Move.Open(moves.Count, upTrendBarData.First(), 2)
.Close(upTrendBarData.Last());
moves.Add(moveGamma);
}
public static BarAnalyzerResult Analyze(IBarDatum workingBar, IBarDatum datum, Trend.TrendType trend)
{
BarAnalyzerResult result = new BarAnalyzerResult();
if (workingBar == null && datum != null)
{
result.WorkingBar = datum;
result.Trend = GetBarTrend(datum);
result.IsValidTrendBar = true;
}
else
{
bool isValidHigh = datum.High > workingBar.High && datum.Low > workingBar.Low;
bool isValidLow = datum.High < workingBar.High && datum.Low < workingBar.Low;
result.IsValidTrendBar = isValidHigh || isValidLow;
if (result.IsValidTrendBar)
{
result.WorkingBar = datum;
result.Trend = isValidHigh ? Trend.TrendType.Up : isValidLow ? Trend.TrendType.Down : Trend.TrendType.Unknown;
}
else
{
result.WorkingBar = workingBar;
result.Trend = trend;
}
}
return(result);
}
public MoveAnalyzerResult(IBarDatum data, IEnumerable <ProspectiveIR> irList)
{
Data = data;
IRList = irList;
}
private void InsertDataList(IBarDatum bd)
{
DataList.Add(bd);
DataListSubject.OnNext(bd);
}
public IWave Close(IMove endingMove)
{
EndBar = endingMove.End;
return(this);
}
public IMoveAnalyzerResult Execute(IMoveManager moveMgr, IMove newMove)
{
// this is for a long break:
// if start is below A, then group A that matches a previous IR
// otherwise group A from previous start. Previous start will the the high of preceding downtrend
// lets see what this looks like without that wrinkle
// List<double> AFromStart = AFromBar(newMove.Start);
IBarDatum barData = newMove.Start;
List <ProspectiveIR> gamma = GammaAnalyzer.GetValues(true, barData); //gamma
// now get union of Highs and lows from MoveMgr
var irList = moveMgr.Highs
.Where(b => b.High > barData.High)
.Select(h => h.High)
.Distinct()
.OrderBy(v => v)
.ToList();
var irLowPoints = moveMgr.Lows
.Where(b => b.Low > barData.High)
.Select(l => l.Low)
.Distinct()
.OrderBy(v => v)
.ToList();
irList.AddRange(irLowPoints.Where(v => !irList.Contains(v)).ToList());
var tempList = new List <double>();
if (barData.High < moveMgr.PreviousMove.Start.Low)
{
List <double> APrevious = AFromBar(moveMgr.PreviousMove.Start);
foreach (var a in APrevious)
{
var possibles = irList.Where(v => Math.Abs(a - v) < 5).ToList();
tempList.AddRange(possibles);
}
}
else
{
tempList = irList;
}
List <ProspectiveIR> resultList = new List <ProspectiveIR>();
foreach (var g in gamma)
{
var possible = tempList.Where(t => Math.Abs(g.Price - t) < 5).ToList().Min();
resultList.Add(new ProspectiveIR(g.Degrees, possible));
}
MoveAnalyzerResult result = new MoveAnalyzerResult(barData, resultList);
return(result);
}
private void BarIsValid(IBarDatum datum)
{
Assert.IsNotNull(datum);
Assert.IsInstanceOfType(datum, typeof(BarDatum));
}
