public void GetChartPoints_IfOnlyMasterPeakExtremumWithLongShadow_OnlyLimitedNumberOfPointsIsCreated()
{
//Arrange
DataSet ds5 = utf.getDataSet(5);
Price basePrice = utf.getPrice(ds5);
Extremum master = new Extremum(basePrice, ExtremumType.PeakByClose);
Quotation quotation5 = new Quotation(ds5)
{
Id = 5, Open = 1.09193, High = 1.09307, Low = 1.09165, Close = 1.09207, Volume = 1819
};
ExtremumGroup extremumGroup = new ExtremumGroup(master, null);
Mock <IProcessManager> mockManager = new Mock <IProcessManager>();
mockManager.Setup(m => m.GetDataSet(5)).Returns(ds5);
//Act
TrendlineProcessor processor = new TrendlineProcessor(mockManager.Object);
//Assert
processor.MaxChartPointsForExtremumGroup = 6;
processor.MinDistanceBetweenChartPoints = 0.0001;
var result = processor.GetChartPoints(extremumGroup);
var expectedResult = new List <ChartPoint>();
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09207));
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09227));
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09247));
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09267));
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09287));
expectedResult.Add(new ChartPoint(master.GetIndexNumber(), 1.09307));
var isEqual = expectedResult.HasEqualItems(result);
Assert.IsTrue(isEqual);
}
private Extremum getDefaultExtremum()
{
Price price = getPrice(DEFAULT_INDEX_NUMBER);
Extremum extremum = new Extremum(price, ExtremumType.PeakByClose)
{
ExtremumId = 1,
LastCheckedDateTime = new DateTime(2017, 3, 5, 12, 0, 0),
Volatility = 1.23,
EarlierCounter = 15,
EarlierAmplitude = 7.45,
EarlierChange1 = 1.12,
EarlierChange2 = 2.21,
EarlierChange3 = 3.12,
EarlierChange5 = 4.56,
EarlierChange10 = 5.28,
LaterCounter = 16,
LaterAmplitude = 1.23,
LaterChange1 = 0.72,
LaterChange2 = 0.54,
LaterChange3 = 1.57,
LaterChange5 = 2.41,
LaterChange10 = 3.15,
Open = true,
Value = 123.42
};
return(extremum);
}
public void AfterProcessing_ExtremumObjectHasProperlyAssignedLaterChange10()
{
//Arrange
Mock <IProcessManager> mockedManager = new Mock <IProcessManager>();
Mock <IExtremumProcessor> mockedProcessor = new Mock <IExtremumProcessor>();
DataSet dataSet4 = utf.getDataSetWithQuotation(4, 1.0915, 1.0916, 1.09111, 1.09112, 1392);
mockedManager.Setup(m => m.GetDataSet(4)).Returns(dataSet4);
mockedProcessor.Setup(p => p.IsExtremum(dataSet4, ExtremumType.TroughByLow)).Returns(true);
mockedProcessor.Setup(p => p.CalculateLaterChange(It.IsAny <Extremum>(), 10)).Returns(1.23);
//Act
PriceProcessor processor = new PriceProcessor(mockedManager.Object);
processor.InjectExtremumProcessor(mockedProcessor.Object);
processor.Process(dataSet4);
//Assert
double expectedValue = 1.23;
Price price = dataSet4.GetPrice();
Extremum extremum = price.GetExtremum(ExtremumType.TroughByLow);
var difference = (extremum.LaterChange10 - expectedValue);
Assert.IsTrue(Math.Abs(difference) < MAX_DOUBLE_COMPARISON_DIFFERENCE);
}
public void NonLinear(decimal current, decimal candidate)
{
Func <decimal, decimal, bool> comparer = (a, b) => a >= b * b;
var strategy = new Extremum(comparer);
Assert.AreEqual(comparer(current, candidate), strategy.Better(current, candidate));
}
public IEnumerable <DataSet> GetDataSets(int assetId, int timeframeId)
{
_repository = new EFQuotationRepository();
var quotationDtos = _repository.GetQuotations(assetId, timeframeId).OrderBy(q => q.DateIndex);
var extremumDtos = _repository.GetExtrema(assetId, timeframeId);
var result = new List <DataSet>();
foreach (var dto in quotationDtos)
{
var ds = new DataSet(assetId, timeframeId, dto.Date, dto.DateIndex);
var quotation = Quotation.FromDto(dto);
ds.quotation = quotation;
ds.price = new Price();
result.Add(ds);
}
foreach (var dto in extremumDtos)
{
var extremum = Extremum.FromDto(dto);
var ds = result.SingleOrDefault(d => d.DateIndex == extremum.DateIndex && d.TimeframeId == extremum.TimeframeId);
if (ds != null && ds.price != null)
{
ds.price.SetExtremum(extremum);
}
}
return(result);
}
#pragma warning disable CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.
/// <summary>Gets the extremum of a collection.</summary>
/// <typeparam name="T">The type of elements stored in the collection.</typeparam>
/// <param name="source">The source collection whose extremum to get.</param>
/// <param name="extremum">The kind of extremum to get.</param>
/// <returns>The extremum of the collection.</returns>
public static T Extremum <T>(this IEnumerable <T> source, Extremum extremum)
{
return(extremum switch
{
Minimum => source.Min(),
Maximum => source.Max(),
});
public void GetChartPoints_IfOnlySlavePeakExtremumWithShortShadow_PointsFromShadowTopToHighestAdjacentShadow()
{
//Arrange
DataSet ds5 = utf.getDataSet(5);
Price price5 = utf.getPrice(ds5);
Quotation quotation5 = new Quotation(ds5)
{
Id = 5, Open = 1.09193, High = 1.09209, Low = 1.09165, Close = 1.09207, Volume = 1819
};
Extremum slave = new Extremum(price5, ExtremumType.PeakByHigh);
ExtremumGroup extremumGroup = new ExtremumGroup(null, slave);
Mock <IProcessManager> mockManager = new Mock <IProcessManager>();
mockManager.Setup(m => m.GetDataSet(5)).Returns(ds5);
//Act
TrendlineProcessor processor = new TrendlineProcessor(mockManager.Object);
processor.MinDistanceBetweenChartPoints = 1;
//Assert
processor.MaxChartPointsForExtremumGroup = 6;
processor.MinDistanceBetweenChartPoints = 0.0001;
var result = processor.GetChartPoints(extremumGroup);
var expectedResult = new List <ChartPoint>();
expectedResult.Add(new ChartPoint(slave.GetIndexNumber(), 1.09207));
expectedResult.Add(new ChartPoint(slave.GetIndexNumber(), 1.09209));
var isEqual = expectedResult.HasEqualItems(result);
Assert.IsTrue(isEqual);
}
public Extremum FindExtremumUniformForUnimodal(double[] poly, double start, double end, double delta)
{
double[] xs = Range.Make(start, end, delta);
Extremum extremum = new Extremum()
{
IsMin = true, X = start
};
Predicate <int> breakCondition = i => Poly.Val(poly, xs[i + 1])[0] >= Poly.Val(poly, xs[i])[0];
if (breakCondition(0))
{
breakCondition = i => Poly.Val(poly, xs[i + 1])[0] <= Poly.Val(poly, xs[i])[0];
extremum.IsMin = false;
}
for (int i = 0; i < xs.Length - 1; ++i)
{
if (breakCondition(i))
{
extremum.X = xs[i] + delta / 2;
return(extremum);
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="deal"></param>
/// <param name="secondExtremum">DEBUG</param>
/// <param name="firstLongExtremums">DEBUG</param>
/// <param name="firstShortExtremums">DEBUG</param>
public DealEvent(Deal deal, Extremum secondExtremum = null, IReadOnlyList<Extremum> firstLongExtremums = null, IReadOnlyList<Extremum> firstShortExtremums = null)
{
FirstShortExtremums = firstShortExtremums;
FirstLongExtremums = firstLongExtremums;
SecondExtremum = secondExtremum;
Deal = deal;
}
public void GetIndexNumberForLevelForTrough_IfThereAreBothQuotationsAndLevelLowerThanMasterLowPrice_ReturnsSlaveQuotationIndexNumber()
{
//Arrange
DataSet ds5 = utf.getDataSet(5);
Price price5 = utf.getPrice(ds5);
Quotation quotation5 = new Quotation(ds5)
{
Id = 5, Open = 1.09127, High = 1.09235, Low = 1.09015, Close = 1.09067, Volume = 1519
};
Extremum master = new Extremum(price5, ExtremumType.TroughByClose);
DataSet ds6 = utf.getDataSet(6);
Price price6 = utf.getPrice(ds6);
Quotation quotation6 = new Quotation(ds6)
{
Id = 6, Open = 1.09067, High = 1.09102, Low = 1.08947, Close = 1.09087, Volume = 1819
};
Extremum slave = new Extremum(price6, ExtremumType.TroughByLow);
ExtremumGroup extremumGroup = new ExtremumGroup(master, slave);
//Act
int indexNumber = extremumGroup.GetIndexNumberForLevel(1.0900);
//Assert
int expectedIndex = 6;
Assert.AreEqual(expectedIndex, indexNumber);
}
public (double[] mins, double[] maxs) FindExtremumsUniform(double[] poly, double start, double end, double delta)
{
List <double> mins = new List <double>();
List <double> maxs = new List <double>();
double lastX = start;
while (lastX <= end)
{
Extremum extremum = FindExtremumUniformForUnimodal(poly, lastX, end, delta);
if (extremum == null)
{
break;
}
if (extremum.IsMin)
{
mins.Add(extremum.X);
}
else
{
maxs.Add(extremum.X);
}
lastX = extremum.X;
}
return(mins.ToArray(), maxs.ToArray());
}
public bool Agrees(Extremum extremum)
{
return(
TestUtilities.IsNearlyEqual(extremum.Value, Value, 10.0 * TestUtilities.TargetPrecision) &&
TestUtilities.IsNearlyEqual(extremum.Location, Location, 10.0 * Math.Sqrt(TestUtilities.TargetPrecision)) &&
(Double.IsNaN(Curvature) || TestUtilities.IsNearlyEqual(extremum.Curvature, Curvature, 0.01))
);
}
public void Serialize(Extremum extremum)
{
var json = JsonConvert.SerializeObject(extremum);
var actual = JsonConvert.DeserializeObject <Extremum>(json);
Assert.NotNull(actual);
Assert.AreEqual(extremum.GetType(), actual.GetType());
}
public void FindMaximaFromPoint()
{
foreach (TestExtremum testExtremum in testMaxima)
{
Extremum extremum = FunctionMath.FindMaximum(testExtremum.Function, testExtremum.Interval.Midpoint);
Assert.IsTrue(TestUtilities.IsNearlyEqual(extremum.Location, testExtremum.Location, Math.Sqrt(TestUtilities.TargetPrecision)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(extremum.Value, testExtremum.Value, TestUtilities.TargetPrecision));
}
}
public void ExtremumGroup_Constructor_IfTroughMasterAndPeakSlaveIsGiven_ExceptionIsThrown()
{
//Arrange
Price p = utf.getPrice(10);
Extremum ex1 = new Extremum(p, ExtremumType.TroughByClose);
Extremum ex2 = new Extremum(p, ExtremumType.PeakByHigh);
//Act
ExtremumGroup eg = new ExtremumGroup(ex1, ex2);
}
public void Deserialize(string extremum)
{
var actual = JsonConvert.DeserializeObject <Extremum>(extremum);
Extremum expected = extremum.Equals("\"max\"", StringComparison.OrdinalIgnoreCase)
? new Maximization() as Extremum
: new Minimization();
Assert.NotNull(actual);
Assert.AreEqual(expected.GetType(), actual.GetType());
}
private int GetDynamicStopLoss(int startPrice, bool isTrendLong, Extremum extremum)
{
/*const double maxStopRatio = 1.5;
* var dist = -GetProfit(isTrendLong, startPrice, extremum.Value);
*
* if (dist > stopLoss && dist < stopLoss*maxStopRatio)
* return dist;*/
return(baseStopLoss);
}
public void FindMinimaFromPoint()
{
foreach (TestExtremum testExtremum in testMinima)
{
Extremum extremum = FunctionMath.FindMinimum(testExtremum.Function, testExtremum.Interval.Midpoint);
Assert.IsTrue(TestUtilities.IsNearlyEqual(extremum.Location, testExtremum.Location, Math.Sqrt(TestUtilities.TargetPrecision)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(extremum.Value, testExtremum.Value, TestUtilities.TargetPrecision));
//if (!Double.IsNaN(testMinimum.Curvature)) Assert.IsTrue(TestUtilities.IsNearlyEqual(minimum.Curvature, testMinimum.Curvature, 0.05));
}
}
public int GetDynamicStopLoss(int startPrice, bool isTrendLong, Extremum extremum)
{
const double maxStopRatio = 1.5;
var dist = -(isTrendLong ? extremum.Value - startPrice : startPrice - extremum.Value);
if (dist > baseStopLoss && dist < baseStopLoss * maxStopRatio)
{
return(dist);
}
return(baseStopLoss);
}
public void ExtremumGroup_Constructor_ForTroughExtremum_IsPeakPropertyIsCorrectlySet()
{
//Arrange
Price p = utf.getPrice(10);
Extremum ex1 = new Extremum(p, ExtremumType.TroughByClose);
Extremum ex2 = new Extremum(p, ExtremumType.TroughByLow);
//Act
ExtremumGroup eg = new ExtremumGroup(ex1, ex2);
//Assert
Assert.AreEqual(false, eg.IsPeak);
}
public void ExtremumGroup_Constructor_IfPeakMasterAndTroughSlaveIsGiven_ExceptionIsThrown()
{
//Arrange
Price p = utf.getPrice(10);
Extremum ex1 = new Extremum(p, ExtremumType.PeakByClose);
Extremum ex2 = new Extremum(p, ExtremumType.TroughByLow);
//Act
ExtremumGroup eg = new ExtremumGroup(ex1, ex2);
//Assert
Assert.AreEqual(false, eg.IsPeak);
}
public void SetExtremum(Extremum extremum)
{
switch (extremum.ExtremumTypeId)
{
case 1: PeakByClose = extremum; break;
case 2: PeakByHigh = extremum; break;
case 3: TroughByClose = extremum; break;
case 4: TroughByLow = extremum; break;
}
}
public void PriceSetExtremum_AfterSettingTroughByLow_ProperExtremumIsAssigned()
{
//Arrange
Price price = getPrice(1);
//Act
Extremum troughByLow = new Extremum(price, ExtremumType.TroughByLow);
price.SetExtremum(troughByLow);
//Assert
Assert.IsTrue(troughByLow == price.TroughByLow);
}
public void PriceSetExtremum_AfterSettingPeakByHigh_ProperExtremumIsAssigned()
{
//Arrange
Price price = getPrice(1);
//Act
Extremum peakByHigh = new Extremum(price, ExtremumType.PeakByHigh);
price.SetExtremum(peakByHigh);
//Assert
Assert.IsTrue(peakByHigh == price.PeakByHigh);
}
public void ExtremumGroup_Constructor_IfOnlySlavePassed_ProperObjectIsCreated()
{
//Arrange
Price p = utf.getPrice(10);
Extremum ex = new Extremum(p, ExtremumType.PeakByHigh);
//Act
ExtremumGroup eg = new ExtremumGroup(null, ex);
//Assert
Assert.IsNotNull(eg);
Assert.AreEqual(ex, eg.MasterExtremum);
Assert.AreEqual(ex, eg.SecondExtremum);
}
public void UpdatePrices_OnlyExtremaFlaggedAsUpdatedAreSendToRepository()
{
//Arrange
QuotationUpdateTester quotationRepository = new QuotationUpdateTester();
PriceUpdateTester priceRepository = new PriceUpdateTester();
List <DataSet> dataSets = new List <DataSet>();
DataSet ds1 = utf.getDataSet(1);
Quotation q1 = utf.getQuotation(ds1);
Price p1 = utf.getPrice(ds1);
DataSet ds2 = utf.getDataSet(2);
Quotation q2 = utf.getQuotation(ds2);
Price p2 = utf.getPrice(ds2);
Extremum ex2 = new Extremum(p2, ExtremumType.PeakByClose);
DataSet ds3 = utf.getDataSet(3);
Quotation q3 = utf.getQuotation(ds3);
Price p3 = utf.getPrice(ds3);
Extremum ex3 = new Extremum(p3, ExtremumType.PeakByHigh);
DataSet ds4 = utf.getDataSet(4);
Quotation q4 = utf.getQuotation(ds4);
Price p4 = utf.getPrice(ds4);
dataSets.AddRange(new DataSet[] { ds1, ds2, ds3, ds4 });
//Act
p2.Updated = true;
p3.Updated = true;
ex3.Updated = true;
p4.New = true;
IDataSetService service = new DataSetService();
service.InjectQuotationRepository(quotationRepository);
service.InjectPriceRepository(priceRepository);
service.UpdateDataSets(dataSets);
//Assert
IEnumerable <ExtremumDto> extremumDtos = priceRepository.GetExtremumDtosPassedForUpdate();
List <ExtremumDto> expectedExtremumDtos = new List <ExtremumDto>();
expectedExtremumDtos.AddRange(new ExtremumDto[] { ex3.ToDto() });
bool areEqual = expectedExtremumDtos.HasEqualItems(extremumDtos);
Assert.IsTrue(areEqual);
}
public void GetIndexNumberForLevelForPeak_ThrowsArgumentException_IfQuotationLevelAboveRange()
{
//Arrange
DataSet ds5 = utf.getDataSet(5);
Price price5 = utf.getPrice(ds5);
Quotation quotation5 = new Quotation(ds5)
{
Id = 5, Open = 1.09127, High = 1.09235, Low = 1.09095, Close = 1.09207, Volume = 1519
};
Extremum master = new Extremum(price5, ExtremumType.PeakByClose);
ExtremumGroup extremumGroup = new ExtremumGroup(master, null);
//Act
int indexNumber = extremumGroup.GetIndexNumberForLevel(1.0941);
}
public void GetIndexNumberForLevelForTrough_ThrowsArgumentException_IfQuotationLevelAboveRange()
{
//Arrange
DataSet ds5 = utf.getDataSet(5);
Price price5 = utf.getPrice(ds5);
Quotation quotation5 = new Quotation(ds5)
{
Id = 5, Open = 1.09127, High = 1.09235, Low = 1.09095, Close = 1.09157, Volume = 1519
};
Extremum slave = new Extremum(price5, ExtremumType.TroughByLow);
ExtremumGroup extremumGroup = new ExtremumGroup(null, slave);
//Act
int indexNumber = extremumGroup.GetIndexNumberForLevel(1.0916);
}
public void ExtremumGroup_Constructor_IfMasterAndSlavedPassed_ProperObjectIsCreated()
{
//Arrange
Price p = utf.getPrice(10);
Extremum ex1 = new Extremum(p, ExtremumType.PeakByClose);
Extremum ex2 = new Extremum(p, ExtremumType.PeakByHigh);
//Act
ExtremumGroup eg = new ExtremumGroup(ex1, ex2);
//Assert
Assert.IsNotNull(eg);
Assert.AreEqual(ex1, eg.MasterExtremum);
Assert.AreEqual(ex2, eg.SecondExtremum);
}
public void FindMinimumOfGamma()
{
int count = 0;
ExtremumSettings settings = new ExtremumSettings()
{
Listener = r => { count++; }
};
Func <double, double> f = new Func <double, double>(AdvancedMath.Gamma);
Extremum minimum = FunctionMath.FindMinimum(f, 1.5, settings);
Assert.IsTrue(TestUtilities.IsNearlyEqual(minimum.Location, 1.46163214496836234126, Math.Sqrt(TestUtilities.TargetPrecision)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(minimum.Value, 0.88560319441088870028));
//Assert.IsTrue(TestUtilities.IsNearlyEqual(minimum.Curvature, Math.Sqrt(Math.Sqrt(0.8569736317111708))));
Assert.IsTrue(count > 0);
}
public void GetLateIndexNumber_IfThereIsOnlySlaveExtremum_SlaveExtremumIndexIsReturned()
{
//Arrange
DataSet ds = utf.getDataSet(51);
Price price = utf.getPrice(ds);
Quotation quotation = new Quotation(ds);
Extremum slave = new Extremum(price, ExtremumType.PeakByHigh);
ExtremumGroup group = new ExtremumGroup(null, slave);
//Assert
int lateIndexNumber = group.GetLateIndexNumber();
//Act
int expected = 51;
Assert.AreEqual(expected, lateIndexNumber);
}
public SecondExtremumEvent(Extremum extremum, ICollection<Extremum> firstLongExtremums, ICollection<Extremum> firstShortExtremums)
{
FirstShortExtremums = firstShortExtremums;
FirstLongExtremums = firstLongExtremums;
Extremum = extremum;
}
