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