From be8bbdeea27231fa2ca66dc728f0ece1805d3bf0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Wed, 10 Apr 2024 20:06:59 +0200 Subject: [PATCH 01/15] Introduced NumFactory - cleaned tests - use builders - eliminated different parameter orders - enforced usage of builder that belongs to series - TODO remove constructors in BaseBar and use BaseBarBuilder --- .../java/org/ta4j/core/BarBuilderFactory.java | 32 ++ .../main/java/org/ta4j/core/BarSeries.java | 193 +-------- .../src/main/java/org/ta4j/core/BaseBar.java | 141 +------ .../java/org/ta4j/core/BaseBarBuilder.java | 13 +- .../org/ta4j/core/BaseBarBuilderFactory.java | 12 + .../ta4j/core/BaseBarConvertibleBuilder.java | 152 ++++--- .../java/org/ta4j/core/BaseBarSeries.java | 308 ++++----------- .../org/ta4j/core/BaseBarSeriesBuilder.java | 85 ++-- .../main/java/org/ta4j/core/Indicator.java | 29 -- .../src/main/java/org/ta4j/core/Trade.java | 2 +- .../aggregator/BaseBarSeriesAggregator.java | 3 +- .../java/org/ta4j/core/analysis/CashFlow.java | 9 +- .../java/org/ta4j/core/analysis/Returns.java | 18 +- .../ta4j/core/backtest/BarSeriesManager.java | 6 +- .../AverageReturnPerBarCriterion.java | 7 +- .../criteria/EnterAndHoldReturnCriterion.java | 6 +- .../core/criteria/ExpectancyCriterion.java | 4 +- .../criteria/ExpectedShortfallCriterion.java | 6 +- .../LinearTransactionCostCriterion.java | 8 +- .../criteria/MaximumDrawdownCriterion.java | 4 +- .../core/criteria/NumberOfBarsCriterion.java | 6 +- .../NumberOfBreakEvenPositionsCriterion.java | 4 +- ...NumberOfConsecutivePositionsCriterion.java | 6 +- .../NumberOfLosingPositionsCriterion.java | 4 +- .../criteria/NumberOfPositionsCriterion.java | 4 +- .../NumberOfWinningPositionsCriterion.java | 4 +- .../criteria/PositionsRatioCriterion.java | 2 +- .../org/ta4j/core/criteria/SqnCriterion.java | 10 +- .../core/criteria/ValueAtRiskCriterion.java | 4 +- .../criteria/VersusEnterAndHoldCriterion.java | 4 +- .../criteria/helpers/AverageCriterion.java | 2 +- .../RelativeStandardDeviationCriterion.java | 2 +- .../helpers/StandardDeviationCriterion.java | 2 +- .../helpers/StandardErrorCriterion.java | 2 +- .../criteria/helpers/VarianceCriterion.java | 6 +- .../criteria/pnl/AverageLossCriterion.java | 8 +- .../criteria/pnl/AverageProfitCriterion.java | 8 +- .../ta4j/core/criteria/pnl/LossCriterion.java | 6 +- .../core/criteria/pnl/ProfitCriterion.java | 8 +- .../criteria/pnl/ProfitLossCriterion.java | 4 +- .../pnl/ProfitLossPercentageCriterion.java | 6 +- .../pnl/ProfitLossRatioCriterion.java | 8 +- .../core/criteria/pnl/ReturnCriterion.java | 6 +- .../core/indicators/AbstractEMAIndicator.java | 2 +- .../ta4j/core/indicators/CCIIndicator.java | 4 +- .../ta4j/core/indicators/CMOIndicator.java | 9 +- .../ChandelierExitLongIndicator.java | 2 +- .../ChandelierExitShortIndicator.java | 2 +- .../ta4j/core/indicators/ChopIndicator.java | 6 +- .../core/indicators/DoubleEMAIndicator.java | 2 +- .../ta4j/core/indicators/FisherIndicator.java | 34 +- .../ta4j/core/indicators/HMAIndicator.java | 3 +- .../IntraDayMomentumIndexIndicator.java | 7 +- .../ta4j/core/indicators/KAMAIndicator.java | 8 +- .../ta4j/core/indicators/KSTIndicator.java | 8 +- .../ta4j/core/indicators/LWMAIndicator.java | 12 +- .../core/indicators/MassIndexIndicator.java | 2 +- .../ta4j/core/indicators/PPOIndicator.java | 4 +- .../indicators/ParabolicSarIndicator.java | 6 +- .../ta4j/core/indicators/RAVIIndicator.java | 2 +- .../ta4j/core/indicators/ROCIndicator.java | 4 +- .../ta4j/core/indicators/RSIIndicator.java | 5 +- .../core/indicators/RWIHighIndicator.java | 4 +- .../ta4j/core/indicators/RWILowIndicator.java | 4 +- .../ta4j/core/indicators/SMAIndicator.java | 5 +- .../StochasticOscillatorKIndicator.java | 2 +- .../core/indicators/TripleEMAIndicator.java | 5 +- .../core/indicators/UlcerIndexIndicator.java | 14 +- .../ta4j/core/indicators/WMAIndicator.java | 7 +- .../core/indicators/WilliamsRIndicator.java | 2 +- .../ta4j/core/indicators/ZLEMAIndicator.java | 6 +- .../ta4j/core/indicators/adx/DXIndicator.java | 9 +- .../core/indicators/adx/MinusDIIndicator.java | 4 +- .../core/indicators/adx/MinusDMIndicator.java | 6 +- .../core/indicators/adx/PlusDIIndicator.java | 4 +- .../core/indicators/adx/PlusDMIndicator.java | 7 +- .../indicators/aroon/AroonDownIndicator.java | 8 +- .../indicators/aroon/AroonUpIndicator.java | 7 +- .../BollingerBandWidthIndicator.java | 7 +- .../BollingerBandsLowerIndicator.java | 2 +- .../BollingerBandsUpperIndicator.java | 2 +- .../bollinger/PercentBIndicator.java | 4 +- .../indicators/candles/DojiIndicator.java | 2 +- .../candles/ThreeBlackCrowsIndicator.java | 2 +- .../DonchianChannelMiddleIndicator.java | 3 +- .../helpers/CloseLocationValueIndicator.java | 6 +- .../ConvergenceDivergenceIndicator.java | 24 +- .../DifferencePercentageIndicator.java | 7 +- .../helpers/FixedDecimalIndicator.java | 4 +- .../indicators/helpers/GainIndicator.java | 5 +- .../indicators/helpers/LossIndicator.java | 5 +- .../helpers/LowestValueIndicator.java | 3 + .../helpers/MedianPriceIndicator.java | 2 +- .../helpers/RunningTotalIndicator.java | 2 +- .../core/indicators/helpers/SumIndicator.java | 2 +- .../helpers/TransformIndicator.java | 14 +- .../helpers/TypicalPriceIndicator.java | 4 +- .../indicators/helpers/VolumeIndicator.java | 3 +- .../ichimoku/IchimokuLineIndicator.java | 4 +- .../IchimokuSenkouSpanAIndicator.java | 4 +- .../keltner/KeltnerChannelLowerIndicator.java | 2 +- .../keltner/KeltnerChannelUpperIndicator.java | 2 +- .../indicators/numeric/NumericIndicator.java | 2 +- .../DeMarkPivotPointIndicator.java | 4 +- .../pivotpoints/DeMarkReversalIndicator.java | 8 +- .../FibonacciReversalIndicator.java | 2 +- .../pivotpoints/PivotPointIndicator.java | 2 +- .../StandardReversalIndicator.java | 2 +- .../statistics/CovarianceIndicator.java | 4 +- .../statistics/MeanDeviationIndicator.java | 4 +- .../PearsonCorrelationIndicator.java | 7 +- .../PeriodicalGrowthRateIndicator.java | 14 +- .../SimpleLinearRegressionIndicator.java | 14 +- .../statistics/StandardErrorIndicator.java | 2 +- .../statistics/VarianceIndicator.java | 5 +- .../supertrend/SuperTrendIndicator.java | 6 +- .../SuperTrendLowerBandIndicator.java | 7 +- .../SuperTrendUpperBandIndicator.java | 5 +- .../AccumulationDistributionIndicator.java | 2 +- .../volume/ChaikinMoneyFlowIndicator.java | 2 +- .../core/indicators/volume/IIIIndicator.java | 8 +- .../volume/MoneyFlowIndexIndicator.java | 14 +- .../core/indicators/volume/NVIIndicator.java | 4 +- .../volume/OnBalanceVolumeIndicator.java | 2 +- .../core/indicators/volume/PVIIndicator.java | 4 +- .../core/indicators/volume/ROCVIndicator.java | 6 +- .../volume/TimeSegmentedVolumeIndicator.java | 7 +- .../core/indicators/volume/VWAPIndicator.java | 3 +- .../java/org/ta4j/core/num/DecimalNum.java | 8 +- .../org/ta4j/core/num/DecimalNumFactory.java | 71 ++++ .../java/org/ta4j/core/num/DoubleNum.java | 10 +- .../org/ta4j/core/num/DoubleNumFactory.java | 71 ++++ .../src/main/java/org/ta4j/core/num/Num.java | 1 + .../java/org/ta4j/core/num/NumFactory.java | 80 ++++ .../core/rules/CrossedDownIndicatorRule.java | 2 +- .../core/rules/CrossedUpIndicatorRule.java | 2 +- .../java/org/ta4j/core/rules/InPipeRule.java | 2 +- .../java/org/ta4j/core/rules/IsEqualRule.java | 2 +- .../ta4j/core/rules/OverIndicatorRule.java | 2 +- .../org/ta4j/core/rules/StopGainRule.java | 4 +- .../org/ta4j/core/rules/StopLossRule.java | 12 +- .../ta4j/core/rules/UnderIndicatorRule.java | 3 +- .../org/ta4j/core/utils/BarSeriesUtils.java | 27 +- .../java/org/ta4j/core/BarSeriesTest.java | 197 +++++---- .../src/test/java/org/ta4j/core/BarTest.java | 20 +- .../org/ta4j/core/BaseBarBuilderTest.java | 8 +- .../core/BaseBarConvertibleBuilderTest.java | 12 +- .../java/org/ta4j/core/IndicatorTest.java | 14 +- .../test/java/org/ta4j/core/PositionTest.java | 7 +- .../java/org/ta4j/core/SeriesBuilderTest.java | 71 ++-- .../java/org/ta4j/core/TestUtilsTest.java | 22 +- .../test/java/org/ta4j/core/TradeTest.java | 12 +- .../java/org/ta4j/core/XlsTestsUtils.java | 74 ++-- .../BaseBarSeriesAggregatorTest.java | 97 +++-- .../aggregator/DurationBarAggregatorTest.java | 204 ++++++++-- .../org/ta4j/core/analysis/CashFlowTest.java | 152 +++---- .../org/ta4j/core/analysis/ReturnsTest.java | 54 +-- .../cost/LinearTransactionCostModelTest.java | 45 ++- .../core/backtest/BarSeriesManagerTest.java | 58 +-- .../AbstractAnalysisCriterionTest.java | 19 +- .../core/criteria/AbstractCriterionTest.java | 19 +- .../AverageReturnPerBarCriterionTest.java | 31 +- .../EnterAndHoldReturnCriterionTest.java | 27 +- .../criteria/ExpectancyCriterionTest.java | 28 +- .../ExpectedShortfallCriterionTest.java | 47 ++- .../LinearTransactionCostCriterionTest.java | 24 +- .../MaximumDrawdownCriterionTest.java | 22 +- .../criteria/NumberOfBarsCriterionTest.java | 22 +- ...mberOfBreakEvenPositionsCriterionTest.java | 28 +- ...erOfConsecutivePositionsCriterionTest.java | 44 ++- .../NumberOfLosingPositionsCriterionTest.java | 28 +- .../NumberOfPositionsCriterionTest.java | 22 +- ...NumberOfWinningPositionsCriterionTest.java | 28 +- .../core/criteria/OpenedPositionUtils.java | 21 +- .../criteria/PositionsRatioCriterionTest.java | 27 +- .../ReturnOverMaxDrawdownCriterionTest.java | 29 +- .../ta4j/core/criteria/SqnCriterionTest.java | 32 +- .../criteria/ValueAtRiskCriterionTest.java | 48 +-- .../VersusEnterAndHoldCriterionTest.java | 26 +- .../ta4j/core/criteria/XLSCriterionTest.java | 15 +- .../helpers/AverageCriterionTest.java | 22 +- ...elativeStandardDeviationCriterionTest.java | 22 +- .../StandardDeviationCriterionTest.java | 22 +- .../helpers/StandardErrorCriterionTest.java | 22 +- .../helpers/VarianceCriterionTest.java | 22 +- .../pnl/AverageLossCriterionTest.java | 36 +- .../pnl/AverageProfitCriterionTest.java | 20 +- .../core/criteria/pnl/LossCriterionTest.java | 22 +- .../criteria/pnl/ProfitCriterionTest.java | 22 +- .../criteria/pnl/ProfitLossCriterionTest.java | 52 +-- .../ProfitLossPercentageCriterionTest.java | 26 +- .../pnl/ProfitLossRatioCriterionTest.java | 20 +- .../criteria/pnl/ReturnCriterionTest.java | 26 +- .../core/indicators/ATRIndicatorTest.java | 69 +++- .../indicators/AbstractIndicatorTest.java | 35 +- ...AccelerationDecelerationIndicatorTest.java | 32 +- .../AwesomeOscillatorIndicatorTest.java | 38 +- .../core/indicators/CCIIndicatorTest.java | 26 +- .../core/indicators/CMOIndicatorTest.java | 19 +- .../core/indicators/CachedIndicatorTest.java | 46 ++- .../ChandelierExitLongIndicatorTest.java | 49 +-- .../ChandelierExitShortIndicatorTest.java | 49 +-- .../core/indicators/ChopIndicatorTest.java | 26 +- .../indicators/CoppockCurveIndicatorTest.java | 22 +- .../core/indicators/DPOIndicatorTest.java | 31 +- .../DistanceFromMAIndicatorTest.java | 13 +- .../indicators/DoubleEMAIndicatorTest.java | 17 +- .../core/indicators/EMAIndicatorTest.java | 29 +- .../core/indicators/FisherIndicatorTest.java | 194 ++++++--- .../core/indicators/HMAIndicatorTest.java | 15 +- .../IntraDayMomentumIndexIndicatorTest.java | 53 ++- .../core/indicators/KAMAIndicatorTest.java | 31 +- .../core/indicators/KSTIndicatorTest.java | 28 +- .../core/indicators/LWMAIndicatorTest.java | 14 +- .../core/indicators/MACDIndicatorTest.java | 19 +- .../core/indicators/MMAIndicatorTest.java | 37 +- .../indicators/MassIndexIndicatorTest.java | 59 ++- .../core/indicators/PPOIndicatorTest.java | 19 +- .../core/indicators/PVOIndicatorTest.java | 32 +- .../indicators/ParabolicSarIndicatorTest.java | 348 ++++++++++++---- .../core/indicators/RAVIIndicatorTest.java | 21 +- .../core/indicators/ROCIndicatorTest.java | 14 +- .../core/indicators/RSIIndicatorTest.java | 48 ++- .../core/indicators/RWIHighIndicatorTest.java | 9 +- .../core/indicators/RWILowIndicatorTest.java | 9 +- .../core/indicators/SMAIndicatorTest.java | 15 +- .../StochasticOscillatorDIndicatorTest.java | 56 ++- .../StochasticOscillatorKIndicatorTest.java | 46 +-- .../StochasticRSIIndicatorTest.java | 20 +- .../indicators/TripleEMAIndicatorTest.java | 17 +- .../indicators/UlcerIndexIndicatorTest.java | 21 +- .../core/indicators/WMAIndicatorTest.java | 20 +- .../indicators/WilliamsRIndicatorTest.java | 48 +-- .../core/indicators/XLSIndicatorTest.java | 11 +- .../core/indicators/ZLEMAIndicatorTest.java | 23 +- .../core/indicators/adx/ADXIndicatorTest.java | 9 +- .../indicators/adx/MinusDIIndicatorTest.java | 7 +- .../indicators/adx/MinusDMIndicatorTest.java | 59 ++- .../indicators/adx/PlusDIIndicatorTest.java | 9 +- .../indicators/adx/PlusDMIndicatorTest.java | 69 ++-- .../aroon/AroonDownIndicatorTest.java | 208 ++++++++-- .../indicators/aroon/AroonFacadeTest.java | 191 +++++++-- .../aroon/AroonOscillatorIndicatorTest.java | 17 +- .../aroon/AroonUpIndicatorTest.java | 78 ++-- .../bollinger/BollingerBandFacadeTest.java | 48 +-- .../BollingerBandWidthIndicatorTest.java | 27 +- .../BollingerBandsLowerIndicatorTest.java | 23 +- .../BollingerBandsMiddleIndicatorTest.java | 17 +- .../BollingerBandsUpperIndicatorTest.java | 21 +- .../bollinger/PercentBIndicatorTest.java | 17 +- .../BearishEngulfingIndicatorTest.java | 29 +- .../candles/BearishHaramiIndicatorTest.java | 29 +- .../BullishEngulfingIndicatorTest.java | 29 +- .../candles/BullishHaramiIndicatorTest.java | 29 +- .../indicators/candles/DojiIndicatorTest.java | 35 +- .../candles/LowerShadowIndicatorTest.java | 27 +- .../candles/RealBodyIndicatorTest.java | 29 +- .../candles/ThreeBlackCrowsIndicatorTest.java | 35 +- .../ThreeWhiteSoldiersIndicatorTest.java | 35 +- .../candles/UpperShadowIndicatorTest.java | 29 +- .../DonchianChannelLowerIndicatorTest.java | 55 +-- .../DonchianChannelMiddleIndicatorTest.java | 49 +-- .../DonchianChannelUpperIndicatorTest.java | 51 +-- .../helpers/AmountIndicatorTest.java | 11 +- .../BooleanTransformIndicatorTest.java | 21 +- .../CloseLocationValueIndicatorTest.java | 33 +- .../ClosePriceDifferenceIndicatorTest.java | 17 +- .../helpers/ClosePriceIndicatorTest.java | 11 +- .../helpers/ClosePriceRatioIndicatorTest.java | 11 +- .../helpers/CombineIndicatorTest.java | 22 +- .../helpers/ConstantIndicatorTest.java | 7 +- .../ConvergenceDivergenceIndicatorTest.java | 4 +- .../helpers/DateTimeIndicatorTest.java | 15 +- .../DifferencePercentageIndicatorTest.java | 30 +- .../helpers/FixedIndicatorTest.java | 11 +- .../indicators/helpers/GainIndicatorTest.java | 15 +- .../helpers/HighPriceIndicatorTest.java | 11 +- .../helpers/HighestValueIndicatorTest.java | 44 ++- .../indicators/helpers/LossIndicatorTest.java | 15 +- .../helpers/LowPriceIndicatorTest.java | 12 +- .../helpers/LowestValueIndicatorTest.java | 26 +- .../helpers/MedianPriceIndicatorTest.java | 36 +- ...dicatorTest.java => NumIndicatorTest.java} | 13 +- .../helpers/OpenPriceIndicatorTest.java | 11 +- .../helpers/PreviousValueIndicatorTest.java | 17 +- .../helpers/RunningTotalIndicatorTest.java | 10 +- .../indicators/helpers/SumIndicatorTest.java | 17 +- .../indicators/helpers/TRIndicatorTest.java | 28 +- .../helpers/TradeCountIndicatorTest.java | 11 +- .../helpers/TransformIndicatorTest.java | 9 +- .../helpers/TypicalPriceIndicatorTest.java | 16 +- .../helpers/UnstableIndicatorTest.java | 13 +- .../helpers/VolumeIndicatorTest.java | 37 +- .../IchimokuChikouSpanIndicatorTest.java | 26 +- .../ichimoku/IchimokuIndicatorTest.java | 64 ++- .../keltner/KeltnerChannelFacadeTest.java | 96 +++-- .../KeltnerChannelLowerIndicatorTest.java | 88 ++--- .../KeltnerChannelMiddleIndicatorTest.java | 248 +++++++++--- .../KeltnerChannelUpperIndicatorTest.java | 87 ++-- .../numeric/NumericIndicatorTest.java | 23 +- .../pivotpoints/PivotPointIndicatorTest.java | 93 +++-- .../CorrelationCoefficientIndicatorTest.java | 53 ++- .../statistics/CovarianceIndicatorTest.java | 58 ++- .../MeanDeviationIndicatorTest.java | 17 +- .../PearsonCorrelationIndicatorTest.java | 53 ++- .../PeriodicalGrowthRateIndicatorTest.java | 24 +- .../statistics/SigmaIndicatorTest.java | 11 +- .../SimpleLinearRegressionIndicatorTest.java | 23 +- .../StandardDeviationIndicatorTest.java | 13 +- .../StandardErrorIndicatorTest.java | 17 +- .../statistics/VarianceIndicatorTest.java | 19 +- .../supertrend/SuperTrendIndicatorTest.java | 84 ++-- .../SuperTrendLowerBandIndicatorTest.java | 66 ++-- .../SuperTrendUpperBandIndicatorTest.java | 63 ++- ...AccumulationDistributionIndicatorTest.java | 31 +- .../volume/ChaikinMoneyFlowIndicatorTest.java | 70 ++-- .../ChaikinOscillatorIndicatorTest.java | 73 ++-- .../indicators/volume/IIIIndicatorTest.java | 34 +- .../indicators/volume/MVWAPIndicatorTest.java | 56 ++- .../volume/MoneyFlowIndexIndicatorTest.java | 85 ++-- .../indicators/volume/NVIIndicatorTest.java | 40 +- .../volume/OnBalanceVolumeIndicatorTest.java | 40 +- .../indicators/volume/PVIIndicatorTest.java | 39 +- .../indicators/volume/ROCVIndicatorTest.java | 36 +- ...eVolumeStandardDeviationIndicatorTest.java | 52 +-- .../TimeSegmentedVolumeIndicatorTest.java | 45 +-- .../indicators/volume/VWAPIndicatorTest.java | 59 ++- .../org/ta4j/core/mocks/MockBarBuilder.java | 45 +++ .../core/mocks/MockBarBuilderFactory.java | 15 + .../org/ta4j/core/mocks/MockBarSeries.java | 110 ------ .../ta4j/core/mocks/MockBarSeriesBuilder.java | 91 +++++ .../org/ta4j/core/mocks/MockIndicator.java | 6 - .../org/ta4j/core/num/DecimalNumTest.java | 266 ++++++++----- .../test/java/org/ta4j/core/num/NumTest.java | 7 +- .../core/rules/BooleanIndicatorRuleTest.java | 5 +- .../org/ta4j/core/rules/ChainRuleTest.java | 15 +- .../rules/CrossedDownIndicatorRuleTest.java | 18 +- .../rules/CrossedUpIndicatorRuleTest.java | 18 +- .../ta4j/core/rules/DayOfWeekRuleTest.java | 28 +- .../org/ta4j/core/rules/InPipeRuleTest.java | 11 +- .../org/ta4j/core/rules/InSlopeRuleTest.java | 8 +- .../org/ta4j/core/rules/IsEqualRuleTest.java | 11 +- .../ta4j/core/rules/IsFallingRuleTest.java | 4 +- .../ta4j/core/rules/IsHighestRuleTest.java | 9 +- .../org/ta4j/core/rules/IsLowestRuleTest.java | 4 +- .../org/ta4j/core/rules/IsRisingRuleTest.java | 8 +- ...OpenedPositionMinimumBarCountRuleTest.java | 41 +- .../core/rules/OverIndicatorRuleTest.java | 6 +- .../org/ta4j/core/rules/StopGainRuleTest.java | 20 +- .../org/ta4j/core/rules/StopLossRuleTest.java | 22 +- .../ta4j/core/rules/TimeRangeRuleTest.java | 36 +- .../core/rules/TrailingStopLossRuleTest.java | 32 +- .../core/rules/UnderIndicatorRuleTest.java | 11 +- .../ta4j/core/utils/BarSeriesUtilsTest.java | 373 ++++++++++++++---- .../main/java/ta4jexamples/Quickstart.java | 4 +- .../SimpleMovingAverageBacktest.java | 41 +- .../barSeries/BuildBarSeries.java | 138 +++---- .../ta4jexamples/loaders/CsvBarsLoader.java | 19 +- .../ta4jexamples/loaders/CsvTradesLoader.java | 20 +- .../loaders/jsonhelper/GsonBarData.java | 16 +- .../ta4jexamples/num/CompareNumTypes.java | 38 +- .../strategies/CCICorrectionStrategy.java | 4 +- 362 files changed, 5900 insertions(+), 4899 deletions(-) create mode 100644 ta4j-core/src/main/java/org/ta4j/core/BarBuilderFactory.java create mode 100644 ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java create mode 100644 ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java create mode 100644 ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java create mode 100644 ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java rename ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/{NumndicatorTest.java => NumIndicatorTest.java} (84%) create mode 100644 ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java create mode 100644 ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java delete mode 100644 ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeries.java create mode 100644 ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java diff --git a/ta4j-core/src/main/java/org/ta4j/core/BarBuilderFactory.java b/ta4j-core/src/main/java/org/ta4j/core/BarBuilderFactory.java new file mode 100644 index 000000000..82c442316 --- /dev/null +++ b/ta4j-core/src/main/java/org/ta4j/core/BarBuilderFactory.java @@ -0,0 +1,32 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2017-2023 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package org.ta4j.core; + +/** + * A factory that provides builders of bars. + */ +public interface BarBuilderFactory { + + BaseBarConvertibleBuilder createBarBuilder(BarSeries series); +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/BarSeries.java b/ta4j-core/src/main/java/org/ta4j/core/BarSeries.java index f45aa3a47..7f85598fc 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BarSeries.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BarSeries.java @@ -24,14 +24,11 @@ package org.ta4j.core; import java.io.Serializable; -import java.math.BigDecimal; -import java.time.Duration; -import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.List; -import java.util.function.Function; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * A {@code BarSeries} is a sequence of {@link Bar bars} separated by a @@ -49,56 +46,19 @@ public interface BarSeries extends Serializable { /** - * @return the name of the series - */ - String getName(); - - /** - * @return any instance of Num to determine its Num type and function. + * @return factory that generates numbers usable in this BarSeries */ - Num num(); + NumFactory numFactory(); /** - * Returns the underlying function to transform a Number into the Num - * implementation used by this bar series - * - * @return a function Number -> Num + * @return builder that generates compatible bars */ - default Function function() { - return num().function(); - } - - /** - * @return the Num of 0 - */ - default Num zero() { - return num().zero(); - } + BaseBarConvertibleBuilder barBuilder(); /** - * @return the Num of 1 - */ - default Num one() { - return num().one(); - } - - /** - * @return the Num of 100 - */ - default Num hundred() { - return num().hundred(); - } - - /** - * Transforms a {@link Number} into the {@link Num implementation} used by this - * bar series - * - * @param number a {@link Number} implementing object. - * @return the corresponding value as a Num implementing object + * @return the name of the series */ - default Num numOf(Number number) { - return num().function().apply(number); - } + String getName(); /** * Gets the bar from {@link #getBarData()} with index {@code i}. @@ -216,8 +176,6 @@ default String getSeriesPeriodDescription() { * Exceeding bars are removed. * * @param bar the bar to be added - * @apiNote to add bar data directly you can use - * {@link #addBar(Duration, ZonedDateTime, Num, Num, Num, Num, Num)} * @see BarSeries#setMaximumBarCount(int) */ default void addBar(Bar bar) { @@ -237,121 +195,10 @@ default void addBar(Bar bar) { * @param replace true to replace the latest bar. Some exchanges continuously * provide new bar data in the respective period, e.g. 1 second * in 1 minute duration. - * @apiNote to add bar data directly you can use - * {@link #addBar(Duration, ZonedDateTime, Num, Num, Num, Num, Num)} * @see BarSeries#setMaximumBarCount(int) */ void addBar(Bar bar, boolean replace); - /** - * Adds the {@code bar} at the end of the series. - * - *

- * The {@code beginIndex} is set to {@code 0} if not already initialized.
- * The {@code endIndex} is set to {@code 0} if not already initialized, or - * incremented if it matches the end of the series.
- * Exceeding bars are removed. - * - * @param timePeriod the {@link Duration} of this bar - * @param endTime the {@link ZonedDateTime end time} of this bar - * @apiNote to add bar data directly you can use - * {@link #addBar(Duration, ZonedDateTime, Num, Num, Num, Num, Num)} - * @see BarSeries#setMaximumBarCount(int) - */ - void addBar(Duration timePeriod, ZonedDateTime endTime); - - default void addBar(ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, Number closePrice) { - this.addBar(endTime, numOf(openPrice), numOf(highPrice), numOf(lowPrice), numOf(closePrice), zero(), zero()); - } - - default void addBar(ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, Number closePrice, - Number volume) { - this.addBar(endTime, numOf(openPrice), numOf(highPrice), numOf(lowPrice), numOf(closePrice), numOf(volume)); - } - - default void addBar(ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, Number closePrice, - Number volume, Number amount) { - this.addBar(endTime, numOf(openPrice), numOf(highPrice), numOf(lowPrice), numOf(closePrice), numOf(volume), - numOf(amount)); - } - - default void addBar(Duration timePeriod, ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, - Number closePrice, Number volume) { - this.addBar(timePeriod, endTime, numOf(openPrice), numOf(highPrice), numOf(lowPrice), numOf(closePrice), - numOf(volume), zero()); - } - - default void addBar(Duration timePeriod, ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, - Number closePrice, Number volume, Number amount) { - this.addBar(timePeriod, endTime, numOf(openPrice), numOf(highPrice), numOf(lowPrice), numOf(closePrice), - numOf(volume), numOf(amount)); - } - - default void addBar(ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, String closePrice) { - this.addBar(endTime, numOf(new BigDecimal(openPrice)), numOf(new BigDecimal(highPrice)), - numOf(new BigDecimal(lowPrice)), numOf(new BigDecimal(closePrice)), zero(), zero()); - } - - default void addBar(ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, String closePrice, - String volume) { - this.addBar(endTime, numOf(new BigDecimal(openPrice)), numOf(new BigDecimal(highPrice)), - numOf(new BigDecimal(lowPrice)), numOf(new BigDecimal(closePrice)), numOf(new BigDecimal(volume)), - zero()); - } - - default void addBar(ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, String closePrice, - String volume, String amount) { - this.addBar(endTime, numOf(new BigDecimal(openPrice)), numOf(new BigDecimal(highPrice)), - numOf(new BigDecimal(lowPrice)), numOf(new BigDecimal(closePrice)), numOf(new BigDecimal(volume)), - numOf(new BigDecimal(amount))); - } - - default void addBar(ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, Num volume) { - this.addBar(endTime, openPrice, highPrice, lowPrice, closePrice, volume, zero()); - } - - /** - * Adds a new {@code Bar} to the bar series. - * - * @param endTime end time of the bar - * @param openPrice the open price - * @param highPrice the high/max price - * @param lowPrice the low/min price - * @param closePrice the last/close price - * @param volume the volume (default zero) - * @param amount the amount (default zero) - */ - void addBar(ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, Num volume, - Num amount); - - /** - * Adds a new {@code Bar} to the bar series. - * - * @param endTime end time of the bar - * @param openPrice the open price - * @param highPrice the high/max price - * @param lowPrice the low/min price - * @param closePrice the last/close price - * @param volume the volume (default zero) - */ - void addBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, - Num volume); - - /** - * Adds a new {@code Bar} to the bar series. - * - * @param timePeriod the time period of the bar - * @param endTime end time of the bar - * @param openPrice the open price - * @param highPrice the high/max price - * @param lowPrice the low/min price - * @param closePrice the last/close price - * @param volume the volume (default zero) - * @param amount the amount (default zero) - */ - void addBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, - Num volume, Num amount); - /** * Adds a trade and updates the close price of the last bar. * @@ -360,18 +207,7 @@ void addBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highP * @see Bar#addTrade(Num, Num) */ default void addTrade(Number tradeVolume, Number tradePrice) { - addTrade(numOf(tradeVolume), numOf(tradePrice)); - } - - /** - * Adds a trade and updates the close price of the last bar. - * - * @param tradeVolume the traded volume - * @param tradePrice the price - * @see Bar#addTrade(Num, Num) - */ - default void addTrade(String tradeVolume, String tradePrice) { - addTrade(numOf(new BigDecimal(tradeVolume)), numOf(new BigDecimal(tradePrice))); + addTrade(numFactory().numOf(tradeVolume), numFactory().numOf(tradePrice)); } /** @@ -392,17 +228,6 @@ default void addTrade(String tradeVolume, String tradePrice) { */ void addPrice(Num price); - /** - * Updates the close price of the last bar. The open, high and low prices are - * also updated as needed. - * - * @param price the price for the bar - * @see Bar#addPrice(Num) - */ - default void addPrice(String price) { - addPrice(new BigDecimal(price)); - } - /** * Updates the close price of the last bar. The open, high and low prices are * also updated as needed. @@ -411,7 +236,7 @@ default void addPrice(String price) { * @see Bar#addPrice(Num) */ default void addPrice(Number price) { - addPrice(numOf(price)); + addPrice(numFactory().numOf(price)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java index fdc8c5353..c59929ed5 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java @@ -32,6 +32,7 @@ import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Base implementation of a {@link Bar}. @@ -50,16 +51,16 @@ public class BaseBar implements Bar { private final ZonedDateTime endTime; /** The open price of the bar period. */ - private Num openPrice = null; + private Num openPrice; /** The high price of the bar period. */ - private Num highPrice = null; + private Num highPrice; /** The low price of the bar period. */ - private Num lowPrice = null; + private Num lowPrice; /** The close price of the bar period. */ - private Num closePrice = null; + private Num closePrice; /** The total traded volume of the bar period. */ private Num volume; @@ -73,17 +74,17 @@ public class BaseBar implements Bar { /** * Constructor. * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param numFunction the numbers precision + * @param timePeriod the time period + * @param endTime the end time of the bar period + * @param numFactory the numbers factory */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, Function numFunction) { + public BaseBar(Duration timePeriod, ZonedDateTime endTime, NumFactory numFactory) { checkTimeArguments(timePeriod, endTime); this.timePeriod = timePeriod; this.endTime = endTime; this.beginTime = endTime.minus(timePeriod); - this.volume = numFunction.apply(0); - this.amount = numFunction.apply(0); + this.volume = numFactory.numOf(0); + this.amount = numFactory.numOf(0); } /** @@ -140,94 +141,6 @@ public BaseBar(Duration timePeriod, ZonedDateTime endTime, double openPrice, dou numFunction.apply(amount), trades); } - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, BigDecimal openPrice, BigDecimal highPrice, - BigDecimal lowPrice, BigDecimal closePrice, BigDecimal volume) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, BigDecimal.ZERO); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, BigDecimal openPrice, BigDecimal highPrice, - BigDecimal lowPrice, BigDecimal closePrice, BigDecimal volume, BigDecimal amount) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, 0, DecimalNum::valueOf); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - * @param trades the number of trades of the bar period - * @param numFunction the numbers precision - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, BigDecimal openPrice, BigDecimal highPrice, - BigDecimal lowPrice, BigDecimal closePrice, BigDecimal volume, BigDecimal amount, long trades, - Function numFunction) { - this(timePeriod, endTime, numFunction.apply(openPrice), numFunction.apply(highPrice), - numFunction.apply(lowPrice), numFunction.apply(closePrice), numFunction.apply(volume), - numFunction.apply(amount), trades); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, - String closePrice, String volume) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, "0"); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, - String closePrice, String volume, String amount) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, "0", DecimalNum::valueOf); - } - /** * Constructor. * @@ -295,38 +208,6 @@ public BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num hi this.trades = trades; } - /** - * @return the {@link BaseBarBuilder} to build a new {@code BaseBar} - */ - public static BaseBarBuilder builder() { - return new BaseBarBuilder(); - } - - /** - * @param the type of the clazz - * @param num any instance of Num to determine its Num function; with this, we - * can convert a {@link Number} of type {@code T} to a {@link Num - * Num implementation} - * @param clazz any type convertable to Num - * @return the {@link BaseBarConvertibleBuilder} to build a new {@code BaseBar} - */ - @SuppressWarnings("unchecked") - public static BaseBarConvertibleBuilder builder(Num num, Class clazz) { - return new BaseBarConvertibleBuilder<>((Function) num.function()); - } - - /** - * @param the type of the clazz - * @param conversionFunction any Num function; with this, we can convert a - * {@link Number} of type {@code T} to a {@link Num - * Num implementation} - * @param clazz any type convertable to Num - * @return the {@link BaseBarConvertibleBuilder} to build a new {@code BaseBar} - */ - public static BaseBarConvertibleBuilder builder(Function conversionFunction, Class clazz) { - return new BaseBarConvertibleBuilder<>(conversionFunction); - } - /** * @return the time period of the bar (must be the same for all bars within the * same {@code BarSeries}) diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilder.java index 49476c598..5d8588d19 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilder.java @@ -25,6 +25,7 @@ import java.time.Duration; import java.time.ZonedDateTime; +import java.util.Objects; import org.ta4j.core.num.Num; @@ -42,9 +43,10 @@ public class BaseBarBuilder { private Num volume; private Num amount; private long trades; + private BarSeries baseBarSeries; /** Constructor to build a {@code BaseBar}. */ - BaseBarBuilder() { + public BaseBarBuilder() { } /** @@ -128,7 +130,16 @@ public BaseBarBuilder trades(long trades) { return this; } + public BaseBarBuilder bindTo(final BarSeries baseBarSeries) { + this.baseBarSeries = Objects.requireNonNull(baseBarSeries); + return this; + } + public BaseBar build() { return new BaseBar(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, trades); } + + public void add() { + baseBarSeries.addBar(build()); + } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java new file mode 100644 index 000000000..c2445db1d --- /dev/null +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java @@ -0,0 +1,12 @@ +package org.ta4j.core; + +/** + * @author Lukáš Kvídera + */ +class BaseBarBuilderFactory implements BarBuilderFactory { + + @Override + public BaseBarConvertibleBuilder createBarBuilder(BarSeries series) { + return new BaseBarConvertibleBuilder(series.numFactory()).bindTo(series); + } +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java index 03545134c..55c2347d8 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java @@ -1,127 +1,169 @@ -/** - * The MIT License (MIT) - * - * Copyright (c) 2017-2023 Ta4j Organization & respective - * authors (see AUTHORS) - * - * Permission is hereby granted, free of charge, to any person obtaining a copy of - * this software and associated documentation files (the "Software"), to deal in - * the Software without restriction, including without limitation the rights to - * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of - * the Software, and to permit persons to whom the Software is furnished to do so, - * subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR - * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER - * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ package org.ta4j.core; import java.time.Duration; import java.time.ZonedDateTime; -import java.util.function.Function; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * A builder to build a new {@code BaseBar} with conversion from a * {@link Number} of type {@code T} to a {@link Num Num implementation}. - * - * @param a {@link Number} of type {@code T} */ -public class BaseBarConvertibleBuilder extends BaseBarBuilder { +public class BaseBarConvertibleBuilder extends BaseBarBuilder { - /** - * The Num function to convert a {@link Number} to a {@link Num Num - * implementation}. - */ - private final Function conversionFunction; + private final NumFactory numFactory; - /** - * Constructor to build a {@code BaseBar}. - * - * @param conversionFunction the Num function to convert a {@link Number} to a - * {@link Num Num implementation} - */ - public BaseBarConvertibleBuilder(Function conversionFunction) { - this.conversionFunction = conversionFunction; + public BaseBarConvertibleBuilder(final NumFactory numFactory) { + this.numFactory = numFactory; } @Override - public BaseBarConvertibleBuilder timePeriod(Duration timePeriod) { + public BaseBarConvertibleBuilder timePeriod(final Duration timePeriod) { super.timePeriod(timePeriod); return this; } @Override - public BaseBarConvertibleBuilder endTime(ZonedDateTime endTime) { + public BaseBarConvertibleBuilder endTime(final ZonedDateTime endTime) { super.endTime(endTime); return this; } @Override - public BaseBarConvertibleBuilder trades(long trades) { + public BaseBarConvertibleBuilder trades(final long trades) { super.trades(trades); return this; } + public BaseBarConvertibleBuilder trades(final String trades) { + super.trades(Long.parseLong(trades)); + return this; + } + + /** + * @param openPrice the open price of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder openPrice(final Number openPrice) { + super.openPrice(numFactory.numOf(openPrice)); + return this; + } + /** * @param openPrice the open price of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder openPrice(T openPrice) { - super.openPrice(conversionFunction.apply(openPrice)); + public BaseBarConvertibleBuilder openPrice(final String openPrice) { + super.openPrice(numFactory.numOf(openPrice)); return this; } /** * @param highPrice the highest price of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder highPrice(final Number highPrice) { + super.highPrice(numFactory.numOf(highPrice)); + return this; + } + + /** + * @param highPrice the highest price of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder highPrice(final String highPrice) { + super.highPrice(numFactory.numOf(highPrice)); + return this; + } + + /** + * @param lowPrice the lowest price of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder highPrice(T highPrice) { - super.highPrice(conversionFunction.apply(highPrice)); + public BaseBarConvertibleBuilder lowPrice(final Number lowPrice) { + super.lowPrice(numFactory.numOf(lowPrice)); return this; } /** * @param lowPrice the lowest price of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder lowPrice(T lowPrice) { - super.lowPrice(conversionFunction.apply(lowPrice)); + public BaseBarConvertibleBuilder lowPrice(final String lowPrice) { + super.lowPrice(numFactory.numOf(lowPrice)); return this; } /** * @param closePrice the close price of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder closePrice(final Number closePrice) { + super.closePrice(numFactory.numOf(closePrice)); + return this; + } + + /** + * @param closePrice the close price of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder closePrice(final String closePrice) { + super.closePrice(numFactory.numOf(closePrice)); + return this; + } + + /** + * @param volume the total traded volume of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder closePrice(T closePrice) { - super.closePrice(conversionFunction.apply(closePrice)); + public BaseBarConvertibleBuilder volume(final Number volume) { + super.volume(numFactory.numOf(volume)); return this; } /** * @param volume the total traded volume of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder volume(T volume) { - super.volume(conversionFunction.apply(volume)); + public BaseBarConvertibleBuilder volume(final String volume) { + super.volume(numFactory.numOf(volume)); return this; } /** * @param amount the total traded amount of the bar period + * * @return {@code this} */ - public BaseBarConvertibleBuilder amount(T amount) { - super.amount(conversionFunction.apply(amount)); + public BaseBarConvertibleBuilder amount(final Number amount) { + super.amount(numFactory.numOf(amount)); + return this; + } + + /** + * @param amount the total traded amount of the bar period + * + * @return {@code this} + */ + public BaseBarConvertibleBuilder amount(final String amount) { + super.amount(numFactory.numOf(amount)); + return this; + } + + @Override + public BaseBarConvertibleBuilder bindTo(final BarSeries baseBarSeries) { + super.bindTo(baseBarSeries); return this; } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java index 86dc1b129..eaf7224e8 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java @@ -23,10 +23,6 @@ */ package org.ta4j.core; -import static org.ta4j.core.num.NaN.NaN; - -import java.math.BigDecimal; -import java.time.Duration; import java.time.ZonedDateTime; import java.util.ArrayList; import java.util.List; @@ -34,8 +30,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Base implementation of a {@link BarSeries}. @@ -47,23 +43,20 @@ public class BaseBarSeries implements BarSeries { /** The logger. */ private final transient Logger log = LoggerFactory.getLogger(getClass()); - /** The {@link #name} for an unnamed bar series. */ - private static final String UNNAMED_SERIES_NAME = "unnamed_series"; - - /** Any instance of Num to determine its Num type. */ - protected final transient Num num; - /** The name of the bar series. */ private final String name; /** The list of bars of the bar series. */ private final List bars; + private final BarBuilderFactory barBuilderFactory; + + private final NumFactory numFactory; /** The begin index of the bar series */ - private int seriesBeginIndex; + private int seriesBeginIndex = -1; /** The end index of the bar series. */ - private int seriesEndIndex; + private int seriesEndIndex = -1; /** The maximum number of bars for the bar series. */ private int maximumBarCount = Integer.MAX_VALUE; @@ -77,112 +70,33 @@ public class BaseBarSeries implements BarSeries { */ private final boolean constrained; - /** Constructor with {@link #name} = {@link #UNNAMED_SERIES_NAME}. */ - public BaseBarSeries() { - this(UNNAMED_SERIES_NAME); - } - - /** - * Constructor. - * - * @param name the name of the bar series - */ - public BaseBarSeries(String name) { - this(name, new ArrayList<>()); - } - - /** - * Constructor with {@link #name} = {@link #UNNAMED_SERIES_NAME}. - * - * @param bars the list of bars of the bar series - */ - public BaseBarSeries(List bars) { - this(UNNAMED_SERIES_NAME, bars); - } - - /** - * Constructor. - * - * @param name the name of the bar series - * @param bars the list of bars of the bar series - */ - public BaseBarSeries(String name, List bars) { - this(name, bars, 0, bars.size() - 1, false); - } - - /** - * Constructor. - * - * @param name the name of the bar series - * @param num any instance of Num to determine its Num function; with this, we - * can convert a {@link Number} to a {@link Num Num implementation} - */ - public BaseBarSeries(String name, Num num) { - this(name, new ArrayList<>(), num); - } - - /** - * Constructor. - * - * @param name the name of the bar series - * @param bars the list of bars of the bar series - * @param num any instance of Num to determine its Num function; with this, we - * can convert a {@link Number} to a {@link Num Num implementation} - */ - public BaseBarSeries(String name, List bars, Num num) { - this(name, bars, 0, bars.size() - 1, false, num); - } - - /** - * Constructor. - *

- * Creates a BaseBarSeries with default {@link DecimalNum} as type for the data - * and all operations on it - * - * @param name the name of the bar series - * @param bars the list of bars of the bar series - * @param seriesBeginIndex the begin index (inclusive) of the bar series - * @param seriesEndIndex the end index (inclusive) of the bar series - * @param constrained true to constrain the bar series (i.e. indexes cannot - * change), false otherwise - */ - private BaseBarSeries(String name, List bars, int seriesBeginIndex, int seriesEndIndex, boolean constrained) { - this(name, bars, seriesBeginIndex, seriesEndIndex, constrained, DecimalNum.ZERO); - } - /** * Constructor. * - * @param name the name of the bar series - * @param bars the list of bars of the bar series - * @param seriesBeginIndex the begin index (inclusive) of the bar series - * @param seriesEndIndex the end index (inclusive) of the bar series - * @param constrained true to constrain the bar series (i.e. indexes cannot - * change), false otherwise - * @param num any instance of Num to determine its Num function; - * with this, we can convert a {@link Number} to a - * {@link Num Num implementation} + * @param name the name of the bar series + * @param bars the list of bars of the bar series + * @param seriesBeginIndex the begin index (inclusive) of the bar series + * @param seriesEndIndex the end index (inclusive) of the bar series + * @param constrained true to constrain the bar series (i.e. indexes + * cannot change), false otherwise + * @param numFactory the factory of numbers used in series {@link Num Num + * implementation} + * @param barBuilderFactory factory for creating bars of this series */ - BaseBarSeries(String name, List bars, int seriesBeginIndex, int seriesEndIndex, boolean constrained, Num num) { + BaseBarSeries(final String name, final List bars, final int seriesBeginIndex, final int seriesEndIndex, + final boolean constrained, final NumFactory numFactory, final BarBuilderFactory barBuilderFactory) { this.name = name; + this.numFactory = numFactory; this.bars = new ArrayList<>(bars); + this.barBuilderFactory = Objects.requireNonNull(barBuilderFactory); if (bars.isEmpty()) { // Bar list empty this.seriesBeginIndex = -1; this.seriesEndIndex = -1; this.constrained = false; - this.num = num; return; } - // Bar list not empty: take Function of first bar - this.num = bars.get(0).getClosePrice(); - // Bar list not empty: checking num types - if (!checkBars(bars)) { - throw new IllegalArgumentException(String.format( - "Num implementation of bars: %s" + " does not match to Num implementation of bar series: %s", - bars.get(0).getClosePrice().getClass(), num.function())); - } // Bar list not empty: checking indexes if (seriesEndIndex < seriesBeginIndex - 1) { throw new IllegalArgumentException("End index must be >= to begin index - 1"); @@ -204,7 +118,7 @@ private BaseBarSeries(String name, List bars, int seriesBeginIndex, int ser * @return a new list of bars with tick from startIndex (inclusive) to endIndex * (exclusive) */ - private static List cut(List bars, final int startIndex, final int endIndex) { + private static List cut(final List bars, final int startIndex, final int endIndex) { return new ArrayList<>(bars.subList(startIndex, endIndex)); } @@ -213,13 +127,13 @@ private static List cut(List bars, final int startIndex, final int end * @param index an out of bounds bar index * @return a message for an OutOfBoundsException */ - private static String buildOutOfBoundsMessage(BaseBarSeries series, int index) { + private static String buildOutOfBoundsMessage(final BaseBarSeries series, final int index) { return String.format("Size of series: %s bars, %s bars removed, index = %s", series.bars.size(), series.removedBarsCount, index); } @Override - public BaseBarSeries getSubSeries(int startIndex, int endIndex) { + public BaseBarSeries getSubSeries(final int startIndex, final int endIndex) { if (startIndex < 0) { throw new IllegalArgumentException(String.format("the startIndex: %s must not be negative", startIndex)); } @@ -227,116 +141,88 @@ public BaseBarSeries getSubSeries(int startIndex, int endIndex) { throw new IllegalArgumentException( String.format("the endIndex: %s must be greater than startIndex: %s", endIndex, startIndex)); } - if (!bars.isEmpty()) { - int start = startIndex - getRemovedBarsCount(); - int end = Math.min(endIndex - getRemovedBarsCount(), this.getEndIndex() + 1); - return new BaseBarSeries(getName(), cut(bars, start, end), num); + if (!this.bars.isEmpty()) { + final int start = startIndex - getRemovedBarsCount(); + final int end = Math.min(endIndex - getRemovedBarsCount(), this.getEndIndex() + 1); + return new BaseBarSeriesBuilder().withName(getName()) + .withBars(cut(this.bars, start, end)) + .withNumFactory(this.numFactory) + .build(); } - return new BaseBarSeries(name, num); + return new BaseBarSeriesBuilder().withNumFactory(this.numFactory).withName(getName()).build(); } @Override - public Num num() { - return num; + public NumFactory numFactory() { + return this.numFactory; } - /** - * Checks if all {@link Bar bars} of a list fits to the {@link Num NumFunction} - * used by this bar series. - * - * @param bars a List of Bar objects. - * @return false if a Num implementation of at least one Bar does not fit. - */ - private boolean checkBars(List bars) { - for (Bar bar : bars) { - if (!checkBar(bar)) { - return false; - } - } - return true; - } - - /** - * Checks if the {@link Num} implementation of a {@link Bar} fits to the - * NumFunction used by this bar series. - * - * @param bar a Bar object. - * @return false if another Num implementation is used than by this bar series. - * @see Num - * @see Bar - * @see #addBar(Duration, ZonedDateTime) - */ - private boolean checkBar(Bar bar) { - if (bar.getClosePrice() == null) { - return true; // bar has not been initialized with data (uses deprecated constructor) - } - // all other constructors initialize at least the close price, check if Num - // implementation fits to numFunction - Class f = one().getClass(); - return f == bar.getClosePrice().getClass() || bar.getClosePrice().equals(NaN); + @Override + public BaseBarConvertibleBuilder barBuilder() { + return barBuilderFactory.createBarBuilder(this); } @Override public String getName() { - return name; + return this.name; } @Override - public Bar getBar(int i) { - int innerIndex = i - removedBarsCount; + public Bar getBar(final int i) { + int innerIndex = i - this.removedBarsCount; if (innerIndex < 0) { if (i < 0) { // Cannot return the i-th bar if i < 0 throw new IndexOutOfBoundsException(buildOutOfBoundsMessage(this, i)); } - if (log.isTraceEnabled()) { - log.trace("Bar series `{}` ({} bars): bar {} already removed, use {}-th instead", name, bars.size(), i, - removedBarsCount); + if (this.log.isTraceEnabled()) { + this.log.trace("Bar series `{}` ({} bars): bar {} already removed, use {}-th instead", this.name, + this.bars.size(), i, this.removedBarsCount); } - if (bars.isEmpty()) { - throw new IndexOutOfBoundsException(buildOutOfBoundsMessage(this, removedBarsCount)); + if (this.bars.isEmpty()) { + throw new IndexOutOfBoundsException(buildOutOfBoundsMessage(this, this.removedBarsCount)); } innerIndex = 0; - } else if (innerIndex >= bars.size()) { + } else if (innerIndex >= this.bars.size()) { // Cannot return the n-th bar if n >= bars.size() throw new IndexOutOfBoundsException(buildOutOfBoundsMessage(this, i)); } - return bars.get(innerIndex); + return this.bars.get(innerIndex); } @Override public int getBarCount() { - if (seriesEndIndex < 0) { + if (this.seriesEndIndex < 0) { return 0; } - final int startIndex = Math.max(removedBarsCount, seriesBeginIndex); - return seriesEndIndex - startIndex + 1; + final int startIndex = Math.max(this.removedBarsCount, this.seriesBeginIndex); + return this.seriesEndIndex - startIndex + 1; } @Override public List getBarData() { - return bars; + return this.bars; } @Override public int getBeginIndex() { - return seriesBeginIndex; + return this.seriesBeginIndex; } @Override public int getEndIndex() { - return seriesEndIndex; + return this.seriesEndIndex; } @Override public int getMaximumBarCount() { - return maximumBarCount; + return this.maximumBarCount; } @Override - public void setMaximumBarCount(int maximumBarCount) { - if (constrained) { + public void setMaximumBarCount(final int maximumBarCount) { + if (this.constrained) { throw new IllegalStateException("Cannot set a maximum bar count on a constrained bar series"); } if (maximumBarCount <= 0) { @@ -348,29 +234,22 @@ public void setMaximumBarCount(int maximumBarCount) { @Override public int getRemovedBarsCount() { - return removedBarsCount; + return this.removedBarsCount; } /** - * @apiNote to add bar data direclty you can use - * {@link #addBar(Duration, ZonedDateTime, Num, Num, Num, Num, Num)} * @throws NullPointerException if {@code bar} is {@code null} */ @Override - public void addBar(Bar bar, boolean replace) { + public void addBar(final Bar bar, final boolean replace) { Objects.requireNonNull(bar, "bar must not be null"); - if (!checkBar(bar)) { - throw new IllegalArgumentException( - String.format("Cannot add Bar with data type: %s to series with data" + "type: %s", - bar.getClosePrice().getClass(), one().getClass())); - } - if (!bars.isEmpty()) { + if (!this.bars.isEmpty()) { if (replace) { - bars.set(bars.size() - 1, bar); + this.bars.set(this.bars.size() - 1, bar); return; } - final int lastBarIndex = bars.size() - 1; - ZonedDateTime seriesEndTime = bars.get(lastBarIndex).getEndTime(); + final int lastBarIndex = this.bars.size() - 1; + final ZonedDateTime seriesEndTime = this.bars.get(lastBarIndex).getEndTime(); if (!bar.getEndTime().isAfter(seriesEndTime)) { throw new IllegalArgumentException( String.format("Cannot add a bar with end time:%s that is <= to series end time: %s", @@ -378,81 +257,46 @@ public void addBar(Bar bar, boolean replace) { } } - bars.add(bar); - if (seriesBeginIndex == -1) { + this.bars.add(bar); + if (this.seriesBeginIndex == -1) { // The begin index is set to 0 if not already initialized: - seriesBeginIndex = 0; + this.seriesBeginIndex = 0; } - seriesEndIndex++; + this.seriesEndIndex++; removeExceedingBars(); } @Override - public void addBar(Duration timePeriod, ZonedDateTime endTime) { - this.addBar(new BaseBar(timePeriod, endTime, function())); - } - - @Override - public void addBar(ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, Num volume) { - this.addBar( - new BaseBar(Duration.ofDays(1), endTime, openPrice, highPrice, lowPrice, closePrice, volume, zero())); - } - - @Override - public void addBar(ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, Num volume, - Num amount) { - this.addBar( - new BaseBar(Duration.ofDays(1), endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount)); - } - - @Override - public void addBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, - Num closePrice, Num volume) { - this.addBar(new BaseBar(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, zero())); - } - - @Override - public void addBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, - Num closePrice, Num volume, Num amount) { - this.addBar(new BaseBar(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount)); - } - - @Override - public void addTrade(Number price, Number amount) { - addTrade(numOf(price), numOf(amount)); - } - - @Override - public void addTrade(String price, String amount) { - addTrade(numOf(new BigDecimal(price)), numOf(new BigDecimal(amount))); + public void addTrade(final Number price, final Number amount) { + addTrade(numFactory().numOf(price), numFactory().numOf(amount)); } @Override - public void addTrade(Num tradeVolume, Num tradePrice) { + public void addTrade(final Num tradeVolume, final Num tradePrice) { getLastBar().addTrade(tradeVolume, tradePrice); } @Override - public void addPrice(Num price) { + public void addPrice(final Num price) { getLastBar().addPrice(price); } /** * Removes the first N bars that exceed the {@link #maximumBarCount}. */ - private void removeExceedingBars() { - int barCount = bars.size(); - if (barCount > maximumBarCount) { + protected void removeExceedingBars() { + final int barCount = this.bars.size(); + if (barCount > this.maximumBarCount) { // Removing old bars - int nbBarsToRemove = barCount - maximumBarCount; + final int nbBarsToRemove = barCount - this.maximumBarCount; if (nbBarsToRemove == 1) { - bars.remove(0); + this.bars.remove(0); } else { - bars.subList(0, nbBarsToRemove).clear(); + this.bars.subList(0, nbBarsToRemove).clear(); } // Updating removed bars count - removedBarsCount += nbBarsToRemove; - seriesBeginIndex = Math.max(seriesBeginIndex, removedBarsCount); + this.removedBarsCount += nbBarsToRemove; + this.seriesBeginIndex = Math.max(this.seriesBeginIndex, this.removedBarsCount); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java index f1e0a6655..0b48ae37c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java @@ -25,52 +25,33 @@ import java.util.ArrayList; import java.util.List; -import java.util.function.Function; -import org.ta4j.core.num.DecimalNum; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; +import org.ta4j.core.num.DecimalNumFactory; +import org.ta4j.core.num.NumFactory; /** * A builder to build a new {@link BaseBarSeries}. */ public class BaseBarSeriesBuilder implements BarSeriesBuilder { - /** Default instance of Num to determine its Num type and function. */ - private static Num defaultNum = DecimalNum.ZERO; + /** The {@link #name} for an unnamed bar series. */ + private static final String UNNAMED_SERIES_NAME = "unnamed_series"; + private List bars; private String name; - private Num num; private boolean constrained; private int maxBarCount; + private NumFactory numFactory = new DecimalNumFactory(); + private BarBuilderFactory barBuilderFactory = new BaseBarBuilderFactory(); /** Constructor to build a {@code BaseBarSeries}. */ public BaseBarSeriesBuilder() { initValues(); } - /** - * @param defaultNum any instance of Num to be used as default to determine its - * Num function; with this, we can convert a {@link Number} to - * a {@link Num Num implementation} - */ - public static void setDefaultNum(Num defaultNum) { - BaseBarSeriesBuilder.defaultNum = defaultNum; - } - - /** - * @param defaultFunction a Num function to be used as default; with this, we - * can convert a {@link Number} to a {@link Num Num - * implementation} - */ - public static void setDefaultNum(Function defaultFunction) { - BaseBarSeriesBuilder.defaultNum = defaultFunction.apply(0); - } - private void initValues() { this.bars = new ArrayList<>(); this.name = "unnamed_series"; - this.num = BaseBarSeriesBuilder.defaultNum; this.constrained = false; this.maxBarCount = Integer.MAX_VALUE; } @@ -83,14 +64,16 @@ public BaseBarSeries build() { beginIndex = 0; endIndex = bars.size() - 1; } - BaseBarSeries series = new BaseBarSeries(name, bars, beginIndex, endIndex, constrained, num); + + var series = new BaseBarSeries(name == null ? UNNAMED_SERIES_NAME : name, bars, beginIndex, endIndex, + constrained, numFactory, barBuilderFactory); series.setMaximumBarCount(maxBarCount); initValues(); // reinitialize values for next series return series; } /** - * @param constrained to set {@link BaseBarSeries#constrained} + * @param constrained to set * @return {@code this} */ public BaseBarSeriesBuilder setConstrained(boolean constrained) { @@ -98,6 +81,15 @@ public BaseBarSeriesBuilder setConstrained(boolean constrained) { return this; } + /** + * @param numFactory to set {@link BaseBarSeries#numFactory()} + * @return {@code this} + */ + public BaseBarSeriesBuilder withNumFactory(NumFactory numFactory) { + this.numFactory = numFactory; + return this; + } + /** * @param name to set {@link BaseBarSeries#getName()} * @return {@code this} @@ -126,41 +118,12 @@ public BaseBarSeriesBuilder withMaxBarCount(int maxBarCount) { } /** - * @param type any instance of Num to determine its Num function; with this, we - * can convert a {@link Number} to a {@link Num Num implementation} - * @return {@code this} - */ - public BaseBarSeriesBuilder withNumTypeOf(Num type) { - this.num = type; - return this; - } - - /** - * @param type any Num function; with this, we can convert a {@link Number} to a - * {@link Num Num implementation} + * @param barBuilderFactory to build bars with the same datatype as series + * * @return {@code this} */ - public BaseBarSeriesBuilder withNumTypeOf(Function function) { - this.num = function.apply(0); + public BaseBarSeriesBuilder withBarBuilderFactory(final BarBuilderFactory barBuilderFactory) { + this.barBuilderFactory = barBuilderFactory; return this; } - - /** - * @param clazz any Num class; with this, we can convert a {@link Number} to a - * {@link Num Num implementation}; if {@code clazz} is not - * registered, then {@link #defaultNum} is used. - * @return {@code this} - */ - public BaseBarSeriesBuilder withNumTypeOf(Class clazz) { - if (clazz == DecimalNum.class) { - this.num = DecimalNum.ZERO; - return this; - } else if (clazz == DoubleNum.class) { - this.num = DoubleNum.ZERO; - return this; - } - this.num = defaultNum; - return this; - } - } diff --git a/ta4j-core/src/main/java/org/ta4j/core/Indicator.java b/ta4j-core/src/main/java/org/ta4j/core/Indicator.java index ff015d6c3..a82a3d049 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/Indicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/Indicator.java @@ -57,34 +57,6 @@ public interface Indicator { */ BarSeries getBarSeries(); - /** - * @return the Num of 0 - */ - default Num zero() { - return getBarSeries().zero(); - } - - /** - * @return the Num of 1 - */ - default Num one() { - return getBarSeries().one(); - } - - /** - * @return the Num of 100 - */ - default Num hundred() { - return getBarSeries().hundred(); - } - - /** - * @return the {@link Num Num extending class} for the given {@link Number} - */ - default Num numOf(Number number) { - return getBarSeries().numOf(number); - } - /** * @return all values from {@code this} Indicator over {@link #getBarSeries()} * as a Stream @@ -111,5 +83,4 @@ static Double[] toDouble(Indicator ref, int index, int barCount) { .map(Num::doubleValue) .toArray(Double[]::new); } - } diff --git a/ta4j-core/src/main/java/org/ta4j/core/Trade.java b/ta4j-core/src/main/java/org/ta4j/core/Trade.java index 7bfac5e15..6673727ee 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/Trade.java +++ b/ta4j-core/src/main/java/org/ta4j/core/Trade.java @@ -104,7 +104,7 @@ public TradeType complementType() { * @param type the trade type */ protected Trade(int index, BarSeries series, TradeType type) { - this(index, series, type, series.one()); + this(index, series, type, series.numFactory().one()); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/aggregator/BaseBarSeriesAggregator.java b/ta4j-core/src/main/java/org/ta4j/core/aggregator/BaseBarSeriesAggregator.java index 41fb123f0..c921f1b30 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/aggregator/BaseBarSeriesAggregator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/aggregator/BaseBarSeriesAggregator.java @@ -28,6 +28,7 @@ import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; /** * Aggregates a {@link BaseBarSeries} into another one using a @@ -49,6 +50,6 @@ public BaseBarSeriesAggregator(BarAggregator barAggregator) { @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List aggregatedBars = barAggregator.aggregate(series.getBarData()); - return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); + return new BaseBarSeriesBuilder().withName(aggregatedSeriesName).withBars(aggregatedBars).build(); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java index 2ff1c5758..293b969c3 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java @@ -53,7 +53,7 @@ public class CashFlow implements Indicator { */ public CashFlow(BarSeries barSeries, Position position) { this.barSeries = barSeries; - values = new ArrayList<>(Collections.singletonList(numOf(1))); + values = new ArrayList<>(Collections.singletonList(barSeries.numFactory().one())); calculate(position); fillToTheEnd(barSeries.getEndIndex()); @@ -79,7 +79,7 @@ public CashFlow(BarSeries barSeries, TradingRecord tradingRecord) { */ public CashFlow(BarSeries barSeries, TradingRecord tradingRecord, int finalIndex) { this.barSeries = barSeries; - values = new ArrayList<>(Collections.singletonList(one())); + values = new ArrayList<>(Collections.singletonList(getBarSeries().numFactory().one())); calculate(tradingRecord, finalIndex); fillToTheEnd(finalIndex); @@ -104,11 +104,6 @@ public BarSeries getBarSeries() { return barSeries; } - @Override - public Num numOf(Number number) { - return barSeries.numOf(number); - } - /** * @return the size of the bar series */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java index 3a2557f72..eb58e59e6 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java @@ -80,7 +80,7 @@ public Num calculate(Num xNew, Num xOld) { * @param type the ReturnType */ public Returns(BarSeries barSeries, Position position, ReturnType type) { - one = barSeries.one(); + one = barSeries.numFactory().one(); this.barSeries = barSeries; this.type = type; // at index 0, there is no return @@ -98,7 +98,7 @@ public Returns(BarSeries barSeries, Position position, ReturnType type) { * @param type the ReturnType */ public Returns(BarSeries barSeries, TradingRecord tradingRecord, ReturnType type) { - one = barSeries.one(); + one = barSeries.numFactory().one(); this.barSeries = barSeries; this.type = type; // at index 0, there is no return @@ -134,11 +134,6 @@ public BarSeries getBarSeries() { return barSeries; } - @Override - public Num numOf(Number number) { - return barSeries.numOf(number); - } - /** * @return the size of the return series. */ @@ -156,12 +151,12 @@ public int getSize() { */ public void calculate(Position position, int finalIndex) { boolean isLongTrade = position.getEntry().isBuy(); - Num minusOne = barSeries.numOf(-1); + Num minusOne = barSeries.numFactory().numOf(-1); int endIndex = CashFlow.determineEndIndex(position, finalIndex, barSeries.getEndIndex()); final int entryIndex = position.getEntry().getIndex(); int begin = entryIndex + 1; if (begin > values.size()) { - values.addAll(Collections.nCopies(begin - values.size(), barSeries.zero())); + values.addAll(Collections.nCopies(begin - values.size(), barSeries.numFactory().zero())); } int startingIndex = Math.max(begin, 1); @@ -223,7 +218,8 @@ private void calculate(TradingRecord tradingRecord) { */ private void fillToTheEnd(int endIndex) { if (endIndex >= values.size()) { - values.addAll(Collections.nCopies(barSeries.getEndIndex() - values.size() + 1, barSeries.zero())); + values.addAll( + Collections.nCopies(barSeries.getEndIndex() - values.size() + 1, barSeries.numFactory().zero())); } } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/backtest/BarSeriesManager.java b/ta4j-core/src/main/java/org/ta4j/core/backtest/BarSeriesManager.java index 48d3cd113..e2118d0be 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/backtest/BarSeriesManager.java +++ b/ta4j-core/src/main/java/org/ta4j/core/backtest/BarSeriesManager.java @@ -147,7 +147,7 @@ public TradingRecord run(Strategy strategy) { * @return the trading record coming from the run */ public TradingRecord run(Strategy strategy, int startIndex, int finishIndex) { - return run(strategy, TradeType.BUY, barSeries.one(), startIndex, finishIndex); + return run(strategy, TradeType.BUY, barSeries.numFactory().one(), startIndex, finishIndex); } /** @@ -160,7 +160,7 @@ public TradingRecord run(Strategy strategy, int startIndex, int finishIndex) { * @return the trading record coming from the run */ public TradingRecord run(Strategy strategy, TradeType tradeType) { - return run(strategy, tradeType, barSeries.one()); + return run(strategy, tradeType, barSeries.numFactory().one()); } /** @@ -176,7 +176,7 @@ public TradingRecord run(Strategy strategy, TradeType tradeType) { * @return the trading record coming from the run */ public TradingRecord run(Strategy strategy, TradeType tradeType, int startIndex, int finishIndex) { - return run(strategy, tradeType, barSeries.one(), startIndex, finishIndex); + return run(strategy, tradeType, barSeries.numFactory().one(), startIndex, finishIndex); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/AverageReturnPerBarCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/AverageReturnPerBarCriterion.java index 8c13d6971..ae32552a4 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/AverageReturnPerBarCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/AverageReturnPerBarCriterion.java @@ -51,14 +51,15 @@ public Num calculate(BarSeries series, Position position) { // If a simple division was used (grossreturn/bars), compounding would not be // considered, leading to inaccuracies in the calculation. // Therefore we need to use "pow" to accurately capture the compounding effect. - return bars.isZero() ? series.one() : grossReturn.calculate(series, position).pow(series.one().dividedBy(bars)); + return bars.isZero() ? series.numFactory().one() + : grossReturn.calculate(series, position).pow(series.numFactory().one().dividedBy(bars)); } @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); - return bars.isZero() ? series.one() - : grossReturn.calculate(series, tradingRecord).pow(series.one().dividedBy(bars)); + return bars.isZero() ? series.numFactory().one() + : grossReturn.calculate(series, tradingRecord).pow(series.numFactory().one().dividedBy(bars)); } /** The higher the criterion value, the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterion.java index 3a9e47a0b..766b51963 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterion.java @@ -78,7 +78,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (series.isEmpty()) { - return series.numOf(1); + return series.numFactory().one(); } int beginIndex = tradingRecord.getStartIndex(series); int endIndex = tradingRecord.getEndIndex(series); @@ -93,8 +93,8 @@ public boolean betterThan(Num criterionValue1, Num criterionValue2) { private Position createEnterAndHoldTrade(BarSeries series, int beginIndex, int endIndex) { Position position = new Position(this.tradeType); - position.operate(beginIndex, series.getBar(beginIndex).getClosePrice(), series.one()); - position.operate(endIndex, series.getBar(endIndex).getClosePrice(), series.one()); + position.operate(beginIndex, series.getBar(beginIndex).getClosePrice(), series.numFactory().one()); + position.operate(endIndex, series.getBar(endIndex).getClosePrice(), series.numFactory().one()); return position; } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectancyCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectancyCriterion.java index 09ed9ae43..47248732e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectancyCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectancyCriterion.java @@ -72,10 +72,10 @@ public boolean betterThan(Num criterionValue1, Num criterionValue2) { private Num calculate(BarSeries series, Num profitLossRatio, Num numberOfWinningPositions, Num numberOfAllPositions) { if (numberOfAllPositions.isZero() || profitLossRatio.isZero()) { - return series.zero(); + return series.numFactory().zero(); } // Expectancy = ((1 + AW/AL) * ProbabilityToWinOnePosition) - 1 - Num one = series.one(); + Num one = series.numFactory().one(); Num probabiltyToWinOnePosition = numberOfWinningPositions.dividedBy(numberOfAllPositions); return (one.plus(profitLossRatio)).multipliedBy(probabiltyToWinOnePosition).minus(one); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectedShortfallCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectedShortfallCriterion.java index 5e45738de..e9d8e9c2c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectedShortfallCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/ExpectedShortfallCriterion.java @@ -59,7 +59,7 @@ public ExpectedShortfallCriterion(double confidence) { @Override public Num calculate(BarSeries series, Position position) { if (position == null || position.getEntry() == null || position.getExit() == null) { - return series.zero(); + return series.numFactory().zero(); } Returns returns = new Returns(series, position, Returns.ReturnType.LOG); return calculateES(returns, confidence); @@ -81,7 +81,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { private static Num calculateES(Returns returns, double confidence) { // select non-NaN returns List returnRates = returns.getValues().subList(1, returns.getSize() + 1); - Num zero = returns.zero(); + Num zero = returns.getBarSeries().numFactory().zero(); if (returnRates.isEmpty()) { return zero; } @@ -97,7 +97,7 @@ private static Num calculateES(Returns returns, double confidence) { for (int i = 0; i < nInTail; i++) { sum = sum.plus(tailEvents.get(i)); } - expectedShortfall = sum.dividedBy(returns.numOf(nInTail)); + expectedShortfall = sum.dividedBy(returns.getBarSeries().numFactory().numOf(nInTail)); // ES is non-positive if (expectedShortfall.isGreaterThan(zero)) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java index ebaa72b67..83b69b1a7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java @@ -75,13 +75,13 @@ public LinearTransactionCostCriterion(double initialAmount, double a, double b) @Override public Num calculate(BarSeries series, Position position) { - return getTradeCost(series, position, series.numOf(initialAmount)); + return getTradeCost(series, position, series.numFactory().numOf(initialAmount)); } @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { - Num totalCosts = series.zero(); - Num tradedAmount = series.numOf(initialAmount); + Num totalCosts = series.numFactory().zero(); + Num tradedAmount = series.numFactory().numOf(initialAmount); for (Position position : tradingRecord.getPositions()) { Num tradeCost = getTradeCost(series, position, tradedAmount); @@ -130,7 +130,7 @@ private Num getTradeCost(Trade trade, Num tradedAmount) { * @return the absolute total cost of all trades in the position */ private Num getTradeCost(BarSeries series, Position position, Num initialAmount) { - Num totalTradeCost = series.zero(); + Num totalTradeCost = series.numFactory().zero(); if (position != null && position.getEntry() != null) { totalTradeCost = getTradeCost(position.getEntry(), initialAmount); if (position.getExit() != null) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/MaximumDrawdownCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/MaximumDrawdownCriterion.java index 2a2849e39..0a366a6a1 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/MaximumDrawdownCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/MaximumDrawdownCriterion.java @@ -45,7 +45,7 @@ public class MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Position position) { if (position == null || position.getEntry() == null || position.getExit() == null) { - return series.zero(); + return series.numFactory().zero(); } CashFlow cashFlow = new CashFlow(series, position); return calculateMaximumDrawdown(series, null, cashFlow); @@ -82,7 +82,7 @@ public boolean betterThan(Num criterionValue1, Num criterionValue2) { */ private Num calculateMaximumDrawdown(BarSeries series, TradingRecord tradingRecord, CashFlow cashFlow) { - Num zero = series.zero(); + Num zero = series.numFactory().zero(); Num maxPeak = zero; Num maximumDrawdown = zero; diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBarsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBarsCriterion.java index 2a5048134..dddd22ce1 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBarsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBarsCriterion.java @@ -41,9 +41,9 @@ public Num calculate(BarSeries series, Position position) { if (position.isClosed()) { final int exitIndex = position.getExit().getIndex(); final int entryIndex = position.getEntry().getIndex(); - return series.numOf(exitIndex - entryIndex + 1); + return series.numFactory().numOf(exitIndex - entryIndex + 1); } - return series.zero(); + return series.numFactory().zero(); } @Override @@ -52,7 +52,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .stream() .filter(Position::isClosed) .map(t -> calculate(series, t)) - .reduce(series.zero(), Num::plus); + .reduce(series.numFactory().zero(), Num::plus); } /** The lower the criterion value, the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterion.java index d59c775ee..d1336bd2e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterion.java @@ -35,7 +35,7 @@ public class NumberOfBreakEvenPositionsCriterion extends AbstractAnalysisCriteri @Override public Num calculate(BarSeries series, Position position) { - return isBreakEvenPosition(position) ? series.one() : series.zero(); + return isBreakEvenPosition(position) ? series.numFactory().one() : series.numFactory().zero(); } @Override @@ -45,7 +45,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .filter(Position::isClosed) .filter(this::isBreakEvenPosition) .count(); - return series.numOf(numberOfBreakEvenTrades); + return series.numFactory().numOf(numberOfBreakEvenTrades); } private boolean isBreakEvenPosition(Position position) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterion.java index 06428774f..51e76d687 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterion.java @@ -46,7 +46,7 @@ public NumberOfConsecutivePositionsCriterion(PositionFilter positionFilter) { @Override public Num calculate(BarSeries series, Position position) { - return isConsecutive(position) ? series.one() : series.zero(); + return isConsecutive(position) ? series.numFactory().one() : series.numFactory().zero(); } @Override @@ -69,7 +69,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { maxConsecutive = consecutives; } - return series.numOf(maxConsecutive); + return series.numFactory().numOf(maxConsecutive); } /** @@ -94,4 +94,4 @@ private boolean isConsecutive(Position position) { return false; } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterion.java index 18cb7f7fa..68898469a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterion.java @@ -35,13 +35,13 @@ public class NumberOfLosingPositionsCriterion extends AbstractAnalysisCriterion @Override public Num calculate(BarSeries series, Position position) { - return position.hasLoss() ? series.one() : series.zero(); + return position.hasLoss() ? series.numFactory().one() : series.numFactory().zero(); } @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingPositions = tradingRecord.getPositions().stream().filter(Position::hasLoss).count(); - return series.numOf(numberOfLosingPositions); + return series.numFactory().numOf(numberOfLosingPositions); } /** The lower the criterion value, the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfPositionsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfPositionsCriterion.java index 60db63885..9c2634d51 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfPositionsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfPositionsCriterion.java @@ -58,12 +58,12 @@ public NumberOfPositionsCriterion(boolean lessIsBetter) { @Override public Num calculate(BarSeries series, Position position) { - return series.one(); + return series.numFactory().one(); } @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { - return series.numOf(tradingRecord.getPositionCount()); + return series.numFactory().numOf(tradingRecord.getPositionCount()); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterion.java index 66659f928..7d737f464 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterion.java @@ -35,13 +35,13 @@ public class NumberOfWinningPositionsCriterion extends AbstractAnalysisCriterion @Override public Num calculate(BarSeries series, Position position) { - return position.hasProfit() ? series.one() : series.zero(); + return position.hasProfit() ? series.numFactory().one() : series.numFactory().zero(); } @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfWinningPositions = tradingRecord.getPositions().stream().filter(Position::hasProfit).count(); - return series.numOf(numberOfWinningPositions); + return series.numFactory().numOf(numberOfWinningPositions); } /** The higher the criterion value, the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/PositionsRatioCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/PositionsRatioCriterion.java index abefb3683..fba177e05 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/PositionsRatioCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/PositionsRatioCriterion.java @@ -82,7 +82,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num numberOfPositions = numberOfPositionsCriterion.calculate(series, tradingRecord); - return numberOfPositions.dividedBy(series.numOf(tradingRecord.getPositionCount())); + return numberOfPositions.dividedBy(series.numFactory().numOf(tradingRecord.getPositionCount())); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/SqnCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/SqnCriterion.java index 2a21425a7..d103c10f3 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/SqnCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/SqnCriterion.java @@ -85,7 +85,7 @@ public SqnCriterion(AnalysisCriterion criterion, Integer nPositions) { public Num calculate(BarSeries series, Position position) { Num stdDevPnl = standardDeviationCriterion.calculate(series, position); if (stdDevPnl.isZero()) { - return series.zero(); + return series.numFactory().zero(); } // SQN = (Average (PnL) / StdDev(PnL)) * SquareRoot(NumberOfTrades) Num numberOfPositions = numberOfPositionsCriterion.calculate(series, position); @@ -97,18 +97,18 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } Num stdDevPnl = standardDeviationCriterion.calculate(series, tradingRecord); if (stdDevPnl.isZero()) { - return series.zero(); + return series.numFactory().zero(); } Num numberOfPositions = numberOfPositionsCriterion.calculate(series, tradingRecord); Num pnl = criterion.calculate(series, tradingRecord); Num avgPnl = pnl.dividedBy(numberOfPositions); - if (nPositions != null && numberOfPositions.isGreaterThan(series.hundred())) { - numberOfPositions = series.numOf(nPositions); + if (nPositions != null && numberOfPositions.isGreaterThan(series.numFactory().hundred())) { + numberOfPositions = series.numFactory().numOf(nPositions); } // SQN = (Average (PnL) / StdDev(PnL)) * SquareRoot(NumberOfTrades) return avgPnl.dividedBy(stdDevPnl).multipliedBy(numberOfPositions.sqrt()); diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/ValueAtRiskCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/ValueAtRiskCriterion.java index 5aefd5dc6..45da22b0f 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/ValueAtRiskCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/ValueAtRiskCriterion.java @@ -55,7 +55,7 @@ public ValueAtRiskCriterion(Double confidence) { @Override public Num calculate(BarSeries series, Position position) { if (position == null || !position.isClosed()) { - return series.zero(); + return series.numFactory().zero(); } Returns returns = new Returns(series, position, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); @@ -75,7 +75,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { * @return the relative Value at Risk */ private static Num calculateVaR(Returns returns, double confidence) { - Num zero = returns.zero(); + Num zero = returns.getBarSeries().numFactory().zero(); // select non-NaN returns List returnRates = returns.getValues().subList(1, returns.getSize() + 1); if (returnRates.isEmpty()) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterion.java index 1a70431c0..e0842a0ac 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterion.java @@ -94,8 +94,8 @@ public boolean betterThan(Num criterionValue1, Num criterionValue2) { private TradingRecord createEnterAndHoldTradingRecord(BarSeries series, int beginIndex, int endIndex) { TradingRecord fakeRecord = new BaseTradingRecord(tradeType); - fakeRecord.enter(beginIndex, series.getBar(beginIndex).getClosePrice(), series.one()); - fakeRecord.exit(endIndex, series.getBar(endIndex).getClosePrice(), series.one()); + fakeRecord.enter(beginIndex, series.getBar(beginIndex).getClosePrice(), series.numFactory().one()); + fakeRecord.exit(endIndex, series.getBar(endIndex).getClosePrice(), series.numFactory().one()); return fakeRecord; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/AverageCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/AverageCriterion.java index f208d99bd..7ad012455 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/AverageCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/AverageCriterion.java @@ -80,7 +80,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } Num numberOfPositions = numberOfPositionsCriterion.calculate(series, tradingRecord); return criterion.calculate(series, tradingRecord).dividedBy(numberOfPositions); diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterion.java index c35f14397..5802e095b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterion.java @@ -86,7 +86,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } Num average = averageCriterion.calculate(series, tradingRecord); return standardDeviationCriterion.calculate(series, tradingRecord).dividedBy(average); diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterion.java index d103aeb7c..a7a4785d3 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterion.java @@ -78,7 +78,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } return varianceCriterion.calculate(series, tradingRecord).sqrt(); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardErrorCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardErrorCriterion.java index 4cc1e3abe..5224025ff 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardErrorCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/StandardErrorCriterion.java @@ -81,7 +81,7 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } Num numberOfPositions = numberOfPositionsCriterion.calculate(series, tradingRecord); return standardDeviationCriterion.calculate(series, tradingRecord).dividedBy(numberOfPositions.sqrt()); diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/VarianceCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/VarianceCriterion.java index 08e6b0654..d8ce6cc42 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/VarianceCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/helpers/VarianceCriterion.java @@ -75,7 +75,7 @@ public Num calculate(BarSeries series, Position position) { Num criterionValue = criterion.calculate(series, position); Num numberOfPositions = numberOfPositionsCriterion.calculate(series, position); - Num variance = series.zero(); + Num variance = series.numFactory().zero(); Num average = criterionValue.dividedBy(numberOfPositions); Num pow = criterion.calculate(series, position).minus(average).pow(2); variance = variance.plus(pow); @@ -86,12 +86,12 @@ public Num calculate(BarSeries series, Position position) { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { if (tradingRecord.getPositions().isEmpty()) { - return series.zero(); + return series.numFactory().zero(); } Num criterionValue = criterion.calculate(series, tradingRecord); Num numberOfPositions = numberOfPositionsCriterion.calculate(series, tradingRecord); - Num variance = series.zero(); + Num variance = series.numFactory().zero(); Num average = criterionValue.dividedBy(numberOfPositions); for (Position position : tradingRecord.getPositions()) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageLossCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageLossCriterion.java index 19913fd7d..e62afbfdb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageLossCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageLossCriterion.java @@ -42,11 +42,11 @@ public class AverageLossCriterion extends AbstractAnalysisCriterion { public Num calculate(BarSeries series, Position position) { Num numberOfLosingPositions = numberOfLosingPositionsCriterion.calculate(series, position); if (numberOfLosingPositions.isZero()) { - return series.zero(); + return series.numFactory().zero(); } Num grossLoss = grossLossCriterion.calculate(series, position); if (grossLoss.isZero()) { - return series.zero(); + return series.numFactory().zero(); } return grossLoss.dividedBy(numberOfLosingPositions); } @@ -55,11 +55,11 @@ public Num calculate(BarSeries series, Position position) { public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num numberOfLosingPositions = numberOfLosingPositionsCriterion.calculate(series, tradingRecord); if (numberOfLosingPositions.isZero()) { - return series.zero(); + return series.numFactory().zero(); } Num grossLoss = grossLossCriterion.calculate(series, tradingRecord); if (grossLoss.isZero()) { - return series.zero(); + return series.numFactory().zero(); } return grossLoss.dividedBy(numberOfLosingPositions); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageProfitCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageProfitCriterion.java index e536a0a23..c431baf77 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageProfitCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/AverageProfitCriterion.java @@ -42,11 +42,11 @@ public class AverageProfitCriterion extends AbstractAnalysisCriterion { public Num calculate(BarSeries series, Position position) { Num numberOfWinningPositions = numberOfWinningPositionsCriterion.calculate(series, position); if (numberOfWinningPositions.isZero()) { - return series.zero(); + return series.numFactory().zero(); } Num grossProfit = grossProfitCriterion.calculate(series, position); if (grossProfit.isZero()) { - return series.zero(); + return series.numFactory().zero(); } return grossProfit.dividedBy(numberOfWinningPositions); } @@ -55,11 +55,11 @@ public Num calculate(BarSeries series, Position position) { public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num numberOfWinningPositions = numberOfWinningPositionsCriterion.calculate(series, tradingRecord); if (numberOfWinningPositions.isZero()) { - return series.zero(); + return series.numFactory().zero(); } Num grossProfit = grossProfitCriterion.calculate(series, tradingRecord); if (grossProfit.isZero()) { - return series.zero(); + return series.numFactory().zero(); } return grossProfit.dividedBy(numberOfWinningPositions); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/LossCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/LossCriterion.java index a925649d6..2e7506fca 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/LossCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/LossCriterion.java @@ -60,9 +60,9 @@ public LossCriterion(boolean excludeCosts) { public Num calculate(BarSeries series, Position position) { if (position.isClosed()) { Num loss = excludeCosts ? position.getGrossProfit() : position.getProfit(); - return loss.isNegative() ? loss : series.zero(); + return loss.isNegative() ? loss : series.numFactory().zero(); } - return series.zero(); + return series.numFactory().zero(); } @@ -72,7 +72,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .stream() .filter(Position::isClosed) .map(position -> calculate(series, position)) - .reduce(series.zero(), Num::plus); + .reduce(series.numFactory().zero(), Num::plus); } /** The higher the criterion value (= the less the loss), the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitCriterion.java index 73b110a93..0776c0322 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitCriterion.java @@ -51,7 +51,7 @@ public ProfitCriterion() { /** * Constructor. * - * @param excludeTradingCosts set to true to exclude trading costs + * @param excludeCosts set to true to exclude trading costs */ public ProfitCriterion(boolean excludeCosts) { this.excludeCosts = excludeCosts; @@ -61,9 +61,9 @@ public ProfitCriterion(boolean excludeCosts) { public Num calculate(BarSeries series, Position position) { if (position.isClosed()) { Num profit = excludeCosts ? position.getGrossProfit() : position.getProfit(); - return profit.isPositive() ? profit : series.zero(); + return profit.isPositive() ? profit : series.numFactory().zero(); } - return series.zero(); + return series.numFactory().zero(); } @Override @@ -72,7 +72,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .stream() .filter(Position::isClosed) .map(position -> calculate(series, position)) - .reduce(series.zero(), Num::plus); + .reduce(series.numFactory().zero(), Num::plus); } /** The higher the criterion value (= the higher the profit), the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossCriterion.java index e4b5ee384..926d88050 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossCriterion.java @@ -48,7 +48,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .stream() .filter(Position::isClosed) .map(position -> calculate(series, position)) - .reduce(series.zero(), Num::plus); + .reduce(series.numFactory().zero(), Num::plus); } /** The higher the criterion value, the better. */ @@ -56,4 +56,4 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterion.java index cfd4d630a..5538bc5b4 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterion.java @@ -44,9 +44,9 @@ public class ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { public Num calculate(BarSeries series, Position position) { if (position.isClosed()) { Num entryPrice = position.getEntry().getValue(); - return position.getProfit().dividedBy(entryPrice).multipliedBy(series.hundred()); + return position.getProfit().dividedBy(entryPrice).multipliedBy(series.numFactory().hundred()); } - return series.zero(); + return series.numFactory().zero(); } @Override @@ -55,7 +55,7 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { .stream() .filter(Position::isClosed) .map(position -> calculate(series, position)) - .reduce(series.zero(), Num::plus); + .reduce(series.numFactory().zero(), Num::plus); } /** The higher the criterion value, the better. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterion.java index 303446158..e12e4267a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterion.java @@ -44,12 +44,12 @@ public Num calculate(BarSeries series, Position position) { Num averageProfit = averageProfitCriterion.calculate(series, position); if (averageProfit.isZero()) { // only loosing positions means a ratio of 0 - return series.zero(); + return series.numFactory().zero(); } Num averageLoss = averageLossCriterion.calculate(series, position); if (averageLoss.isZero()) { // only winning positions means a ratio of 1 - return series.one(); + return series.numFactory().one(); } return averageProfit.dividedBy(averageLoss).abs(); } @@ -59,12 +59,12 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num averageProfit = averageProfitCriterion.calculate(series, tradingRecord); if (averageProfit.isZero()) { // only loosing positions means a ratio of 0 - return series.zero(); + return series.numFactory().zero(); } Num averageLoss = averageLossCriterion.calculate(series, tradingRecord); if (averageLoss.isZero()) { // only winning positions means a ratio of 1 - return series.one(); + return series.numFactory().one(); } return averageProfit.dividedBy(averageLoss).abs(); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ReturnCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ReturnCriterion.java index e932720b0..eefdce244 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ReturnCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/pnl/ReturnCriterion.java @@ -71,8 +71,8 @@ public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getPositions() .stream() .map(position -> calculateProfit(series, position)) - .reduce(series.one(), Num::multipliedBy) - .minus(addBase ? series.zero() : series.one()); + .reduce(series.numFactory().one(), Num::multipliedBy) + .minus(addBase ? series.numFactory().zero() : series.numFactory().one()); } /** The higher the criterion value, the better. */ @@ -92,6 +92,6 @@ private Num calculateProfit(BarSeries series, Position position) { if (position.isClosed()) { return position.getGrossReturn(series); } - return addBase ? series.one() : series.zero(); + return addBase ? series.numFactory().one() : series.numFactory().zero(); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/AbstractEMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/AbstractEMAIndicator.java index 41fd75ff8..218613e9c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/AbstractEMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/AbstractEMAIndicator.java @@ -46,7 +46,7 @@ protected AbstractEMAIndicator(Indicator indicator, int barCount, double mu super(indicator); this.indicator = indicator; this.barCount = barCount; - this.multiplier = numOf(multiplier); + this.multiplier = getBarSeries().numFactory().numOf(multiplier); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/CCIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/CCIIndicator.java index bad150857..0b4c514bc 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/CCIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/CCIIndicator.java @@ -51,7 +51,7 @@ public class CCIIndicator extends CachedIndicator { */ public CCIIndicator(BarSeries series, int barCount) { super(series); - this.factor = numOf(0.015); + this.factor = getBarSeries().numFactory().numOf(0.015); this.typicalPriceInd = new TypicalPriceIndicator(series); this.smaInd = new SMAIndicator(typicalPriceInd, barCount); this.meanDeviationInd = new MeanDeviationIndicator(typicalPriceInd, barCount); @@ -64,7 +64,7 @@ protected Num calculate(int index) { final Num typicalPriceAvg = smaInd.getValue(index); final Num meanDeviation = meanDeviationInd.getValue(index); if (meanDeviation.isZero()) { - return zero(); + return getBarSeries().numFactory().zero(); } return (typicalPrice.minus(typicalPriceAvg)).dividedBy(meanDeviation.multipliedBy(factor)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/CMOIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/CMOIndicator.java index 7bd63d360..2b30ecbcb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/CMOIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/CMOIndicator.java @@ -43,7 +43,6 @@ public class CMOIndicator extends CachedIndicator { private final GainIndicator gainIndicator; private final LossIndicator lossIndicator; private final int barCount; - private final Num hundred; /** * Constructor. @@ -56,19 +55,19 @@ public CMOIndicator(Indicator indicator, int barCount) { this.gainIndicator = new GainIndicator(indicator); this.lossIndicator = new LossIndicator(indicator); this.barCount = barCount; - this.hundred = hundred(); } @Override protected Num calculate(int index) { - Num sumOfGains = zero(); - Num sumOfLosses = zero(); + final var numFactory = getBarSeries().numFactory(); + Num sumOfGains = numFactory.zero(); + Num sumOfLosses = numFactory.zero(); for (int i = Math.max(1, index - barCount + 1); i <= index; i++) { sumOfGains = sumOfGains.plus(gainIndicator.getValue(i)); sumOfLosses = sumOfLosses.plus(lossIndicator.getValue(i)); } - return sumOfGains.minus(sumOfLosses).dividedBy(sumOfGains.plus(sumOfLosses)).multipliedBy(hundred); + return sumOfGains.minus(sumOfLosses).dividedBy(sumOfGains.plus(sumOfLosses)).multipliedBy(numFactory.hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitLongIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitLongIndicator.java index 71170a544..ca8045a99 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitLongIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitLongIndicator.java @@ -66,7 +66,7 @@ public ChandelierExitLongIndicator(BarSeries series, int barCount, double k) { super(series); this.high = new HighestValueIndicator(new HighPriceIndicator(series), barCount); this.atr = new ATRIndicator(series, barCount); - this.k = numOf(k); + this.k = getBarSeries().numFactory().numOf(k); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitShortIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitShortIndicator.java index 5c300e27d..4c4f29713 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitShortIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChandelierExitShortIndicator.java @@ -66,7 +66,7 @@ public ChandelierExitShortIndicator(BarSeries series, int barCount, double k) { super(series); this.low = new LowestValueIndicator(new LowPriceIndicator(series), barCount); this.atr = new ATRIndicator(series, barCount); - this.k = numOf(k); + this.k = getBarSeries().numFactory().numOf(k); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChopIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChopIndicator.java index 964959a99..e2855e4b8 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ChopIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ChopIndicator.java @@ -75,8 +75,8 @@ public ChopIndicator(BarSeries barSeries, int ciTimeFrame, int scaleTo) { this.hvi = new HighestValueIndicator(new HighPriceIndicator(barSeries), ciTimeFrame); this.lvi = new LowestValueIndicator(new LowPriceIndicator(barSeries), ciTimeFrame); this.timeFrame = ciTimeFrame; - this.log10n = numOf(Math.log10(ciTimeFrame)); - this.scaleUpTo = numOf(scaleTo); + this.log10n = getBarSeries().numFactory().numOf(Math.log10(ciTimeFrame)); + this.scaleUpTo = getBarSeries().numFactory().numOf(scaleTo); } @Override @@ -87,7 +87,7 @@ public Num calculate(int index) { } Num a = summ.dividedBy((hvi.getValue(index).minus(lvi.getValue(index)))); // TODO: implement Num.log10(Num) - return scaleUpTo.multipliedBy(numOf(Math.log10(a.doubleValue()))).dividedBy(log10n); + return scaleUpTo.multipliedBy(getBarSeries().numFactory().numOf(Math.log10(a.doubleValue()))).dividedBy(log10n); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/DoubleEMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/DoubleEMAIndicator.java index eecca802e..065f85bd8 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/DoubleEMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/DoubleEMAIndicator.java @@ -48,7 +48,7 @@ public class DoubleEMAIndicator extends CachedIndicator { */ public DoubleEMAIndicator(Indicator indicator, int barCount) { super(indicator); - this.two = numOf(2); + this.two = getBarSeries().numFactory().two(); this.barCount = barCount; this.ema = new EMAIndicator(indicator, barCount); this.emaEma = new EMAIndicator(ema, barCount); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/FisherIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/FisherIndicator.java index 53da8ace8..c39a31ff7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/FisherIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/FisherIndicator.java @@ -141,13 +141,14 @@ public FisherIndicator(Indicator ref, int barCount, final double alphaD, fi final double gammaD, final double deltaD, double densityFactorD, boolean isPriceIndicator) { super(ref); this.ref = ref; - this.gamma = numOf(gammaD); - this.delta = numOf(deltaD); - this.densityFactor = numOf(densityFactorD); - this.one = one(); - - Num alpha = numOf(alphaD); - Num beta = numOf(betaD); + final var numFactory = getBarSeries().numFactory(); + this.gamma = numFactory.numOf(gammaD); + this.delta = numFactory.numOf(deltaD); + this.densityFactor = numFactory.numOf(densityFactorD); + this.one = numFactory.one(); + + Num alpha = numFactory.numOf(alphaD); + Num beta = numFactory.numOf(betaD); final Indicator periodHigh = new HighestValueIndicator( isPriceIndicator ? new HighPriceIndicator(ref.getBarSeries()) : ref, barCount); final Indicator periodLow = new LowestValueIndicator( @@ -158,7 +159,7 @@ public FisherIndicator(Indicator ref, int barCount, final double alphaD, fi @Override protected Num calculate(int index) { if (index <= 0) { - return zero(); + return numFactory.zero(); } // Value = (alpha * 2 * ((ref - MinL) / (MaxH - MinL) - 0.5) + beta * @@ -166,8 +167,8 @@ protected Num calculate(int index) { Num currentRef = FisherIndicator.this.ref.getValue(index); Num minL = periodLow.getValue(index); Num maxH = periodHigh.getValue(index); - Num term1 = currentRef.minus(minL).dividedBy(maxH.minus(minL)).minus(numOf(ZERO_DOT_FIVE)); - Num term2 = alpha.multipliedBy(numOf(2)).multipliedBy(term1); + Num term1 = currentRef.minus(minL).dividedBy(maxH.minus(minL)).minus(numFactory.numOf(ZERO_DOT_FIVE)); + Num term2 = alpha.multipliedBy(numFactory.numOf(2)).multipliedBy(term1); Num term3 = term2.plus(beta.multipliedBy(getValue(index - 1))); return term3.dividedBy(FisherIndicator.this.densityFactor); } @@ -181,20 +182,21 @@ public int getUnstableBars() { @Override protected Num calculate(int index) { + final var numFactory = getBarSeries().numFactory(); if (index <= 0) { - return zero(); + return numFactory.zero(); } Num value = intermediateValue.getValue(index); - if (value.isGreaterThan(numOf(VALUE_MAX))) { - value = numOf(VALUE_MAX); - } else if (value.isLessThan(numOf(VALUE_MIN))) { - value = numOf(VALUE_MIN); + if (value.isGreaterThan(numFactory.numOf(VALUE_MAX))) { + value = numFactory.numOf(VALUE_MAX); + } else if (value.isLessThan(numFactory.numOf(VALUE_MIN))) { + value = numFactory.numOf(VALUE_MIN); } // Fisher = gamma * Log((1 + Value) / (1 - Value)) + delta * priorFisher - Num term1 = numOf((Math.log(one.plus(value).dividedBy(one.minus(value)).doubleValue()))); + Num term1 = numFactory.numOf((Math.log(one.plus(value).dividedBy(one.minus(value)).doubleValue()))); Num term2 = getValue(index - 1); return gamma.multipliedBy(term1).plus(delta.multipliedBy(term2)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/HMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/HMAIndicator.java index e13acd2c9..b0c5b7194 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/HMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/HMAIndicator.java @@ -53,7 +53,8 @@ public HMAIndicator(Indicator indicator, int barCount) { WMAIndicator origWma = new WMAIndicator(indicator, barCount); Indicator indicatorForSqrtWma = CombineIndicator.minus(TransformIndicator.multiply(halfWma, 2), origWma); - this.sqrtWma = new WMAIndicator(indicatorForSqrtWma, numOf(barCount).sqrt().intValue()); + this.sqrtWma = new WMAIndicator(indicatorForSqrtWma, + getBarSeries().numFactory().numOf(barCount).sqrt().intValue()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicator.java index 55f9345d0..fa219196a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicator.java @@ -23,13 +23,13 @@ */ package org.ta4j.core.indicators; +import static org.ta4j.core.num.NaN.NaN; + import org.ta4j.core.BarSeries; import org.ta4j.core.indicators.candles.RealBodyIndicator; import org.ta4j.core.indicators.helpers.TransformIndicator; import org.ta4j.core.num.Num; -import static org.ta4j.core.num.NaN.NaN; - /** * IntraDay Momentum Index Indicator. *

@@ -80,7 +80,8 @@ protected Num calculate(int index) { Num avgOpenCloseValue = this.averageOpenCloseDiff.getValue(index); // Calculate the momentum index - return avgCloseOpenValue.dividedBy((avgCloseOpenValue.plus(avgOpenCloseValue))).multipliedBy(hundred()); + return avgCloseOpenValue.dividedBy((avgCloseOpenValue.plus(avgOpenCloseValue))) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/KAMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/KAMAIndicator.java index 604821547..f8c153f1c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/KAMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/KAMAIndicator.java @@ -53,8 +53,10 @@ public KAMAIndicator(Indicator price, int barCountEffectiveRatio, int barCo super(price); this.price = price; this.barCountEffectiveRatio = barCountEffectiveRatio; - this.fastest = numOf(2).dividedBy(numOf(barCountFast + 1)); - this.slowest = numOf(2).dividedBy(numOf(barCountSlow + 1)); + final var numFactory = getBarSeries().numFactory(); + final var two = numFactory.two(); + this.fastest = two.dividedBy(numFactory.numOf(barCountFast + 1)); + this.slowest = two.dividedBy(numFactory.numOf(barCountSlow + 1)); } /** @@ -86,7 +88,7 @@ protected Num calculate(int index) { */ int startChangeIndex = Math.max(0, index - barCountEffectiveRatio); Num change = currentPrice.minus(price.getValue(startChangeIndex)).abs(); - Num volatility = zero(); + Num volatility = getBarSeries().numFactory().zero(); for (int i = startChangeIndex; i < index; i++) { volatility = volatility.plus(price.getValue(i + 1).minus(price.getValue(i)).abs()); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/KSTIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/KSTIndicator.java index de96db70d..943f92afb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/KSTIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/KSTIndicator.java @@ -49,10 +49,10 @@ public class KSTIndicator extends CachedIndicator { private final SMAIndicator RCMA2; private final SMAIndicator RCMA3; private final SMAIndicator RCMA4; - private final Num RCMA1_Multiplier = one(); - private final Num RCMA2_Multiplier = numOf(2); - private final Num RCMA3_Multiplier = numOf(3); - private final Num RCMA4_Multiplier = numOf(4); + private final Num RCMA1_Multiplier = getBarSeries().numFactory().one(); + private final Num RCMA2_Multiplier = getBarSeries().numFactory().numOf(2); + private final Num RCMA3_Multiplier = getBarSeries().numFactory().numOf(3); + private final Num RCMA4_Multiplier = getBarSeries().numFactory().numOf(4); /** * Constructor with: diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/LWMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/LWMAIndicator.java index dbf7a22c1..eee5c6f0b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/LWMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/LWMAIndicator.java @@ -37,7 +37,6 @@ public class LWMAIndicator extends CachedIndicator { private final Indicator indicator; private final int barCount; - private final Num zero = zero(); /** * Constructor. @@ -53,19 +52,20 @@ public LWMAIndicator(Indicator indicator, int barCount) { @Override protected Num calculate(int index) { - Num sum = zero; - Num denominator = zero; + final var numFactory = getBarSeries().numFactory(); + Num sum = numFactory.zero(); + Num denominator = numFactory.zero(); int count = 0; if ((index + 1) < barCount) { - return zero; + return numFactory.zero(); } int startIndex = (index - barCount) + 1; for (int i = startIndex; i <= index; i++) { count++; - denominator = denominator.plus(numOf(count)); - sum = sum.plus(indicator.getValue(i).multipliedBy(numOf(count))); + denominator = denominator.plus(numFactory.numOf(count)); + sum = sum.plus(indicator.getValue(i).multipliedBy(numFactory.numOf(count))); } return sum.dividedBy(denominator); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/MassIndexIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/MassIndexIndicator.java index f2a7536e8..92c55e556 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/MassIndexIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/MassIndexIndicator.java @@ -62,7 +62,7 @@ public MassIndexIndicator(BarSeries series, int emaBarCount, int barCount) { @Override protected Num calculate(int index) { final int startIndex = Math.max(0, index - barCount + 1); - Num massIndex = zero(); + Num massIndex = getBarSeries().numFactory().zero(); for (int i = startIndex; i <= index; i++) { Num emaRatio = singleEma.getValue(i).dividedBy(doubleEma.getValue(i)); massIndex = massIndex.plus(emaRatio); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/PPOIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/PPOIndicator.java index 02fe1a215..cd1f6f59a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/PPOIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/PPOIndicator.java @@ -72,7 +72,9 @@ public PPOIndicator(Indicator indicator, int shortBarCount, int longBarCoun protected Num calculate(int index) { Num shortEmaValue = shortTermEma.getValue(index); Num longEmaValue = longTermEma.getValue(index); - return shortEmaValue.minus(longEmaValue).dividedBy(longEmaValue).multipliedBy(hundred()); + return shortEmaValue.minus(longEmaValue) + .dividedBy(longEmaValue) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ParabolicSarIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ParabolicSarIndicator.java index e47fb6085..3aaa71bd7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ParabolicSarIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ParabolicSarIndicator.java @@ -74,7 +74,7 @@ public class ParabolicSarIndicator extends RecursiveCachedIndicator { * @param series the bar series for this indicator */ public ParabolicSarIndicator(BarSeries series) { - this(series, series.numOf(0.02), series.numOf(0.2), series.numOf(0.02)); + this(series, series.numFactory().numOf(0.02), series.numFactory().numOf(0.2), series.numFactory().numOf(0.02)); } /** @@ -85,7 +85,7 @@ public ParabolicSarIndicator(BarSeries series) { * @param maxA maximum acceleration */ public ParabolicSarIndicator(BarSeries series, Num aF, Num maxA) { - this(series, aF, maxA, series.numOf(0.02)); + this(series, aF, maxA, series.numFactory().numOf(0.02)); } /** @@ -140,7 +140,7 @@ private Num calculateInternal(int index) { if (index == seriesStartIndex) { lastExtreme.put(index, getBarSeries().getBar(index).getClosePrice()); - lastAf.put(index, zero()); + lastAf.put(index, getBarSeries().numFactory().zero()); isUpTrendMap.put(index, false); return sar; // no trend detection possible for the first value } else if (index == seriesStartIndex + 1) { // start trend detection diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/RAVIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/RAVIIndicator.java index bf47ab58c..204f2f232 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/RAVIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/RAVIIndicator.java @@ -54,7 +54,7 @@ public RAVIIndicator(Indicator price, int shortSmaBarCount, int longSmaBarC protected Num calculate(int index) { Num shortMA = shortSma.getValue(index); Num longMA = longSma.getValue(index); - return shortMA.minus(longMA).dividedBy(longMA).multipliedBy(hundred()); + return shortMA.minus(longMA).dividedBy(longMA).multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ROCIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ROCIndicator.java index 16aa5a3d0..b64c64554 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ROCIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ROCIndicator.java @@ -58,7 +58,9 @@ protected Num calculate(int index) { int nIndex = Math.max(index - barCount, 0); Num nPeriodsAgoValue = indicator.getValue(nIndex); Num currentValue = indicator.getValue(index); - return currentValue.minus(nPeriodsAgoValue).dividedBy(nPeriodsAgoValue).multipliedBy(hundred()); + return currentValue.minus(nPeriodsAgoValue) + .dividedBy(nPeriodsAgoValue) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/RSIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/RSIIndicator.java index d126cc8de..a34194479 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/RSIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/RSIIndicator.java @@ -56,12 +56,13 @@ protected Num calculate(int index) { // compute relative strength Num averageGain = averageGainIndicator.getValue(index); Num averageLoss = averageLossIndicator.getValue(index); + final var numFactory = getBarSeries().numFactory(); if (averageLoss.isZero()) { - return averageGain.isZero() ? zero() : hundred(); + return averageGain.isZero() ? numFactory.zero() : numFactory.hundred(); } Num relativeStrength = averageGain.dividedBy(averageLoss); // compute relative strength index - return hundred().minus(hundred().dividedBy(one().plus(relativeStrength))); + return numFactory.hundred().minus(numFactory.hundred().dividedBy(numFactory.one().plus(relativeStrength))); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/RWIHighIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/RWIHighIndicator.java index 2488b0ca4..0acc6585b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/RWIHighIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/RWIHighIndicator.java @@ -55,7 +55,7 @@ protected Num calculate(int index) { return NaN.NaN; } - Num maxRWIH = numOf(0); + Num maxRWIH = getBarSeries().numFactory().zero(); for (int n = 2; n <= barCount; n++) { maxRWIH = maxRWIH.max(calcRWIHFor(index, n)); } @@ -73,7 +73,7 @@ private Num calcRWIHFor(final int index, final int n) { Num high = series.getBar(index).getHighPrice(); Num lowN = series.getBar(index + 1 - n).getLowPrice(); Num atrN = new ATRIndicator(series, n).getValue(index); - Num sqrtN = numOf(n).sqrt(); + Num sqrtN = getBarSeries().numFactory().numOf(n).sqrt(); return high.minus(lowN).dividedBy(atrN.multipliedBy(sqrtN)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/RWILowIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/RWILowIndicator.java index 6bca00f00..19f78c319 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/RWILowIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/RWILowIndicator.java @@ -55,7 +55,7 @@ protected Num calculate(int index) { return NaN.NaN; } - Num minRWIL = zero(); + Num minRWIL = getBarSeries().numFactory().zero(); for (int n = 2; n <= barCount; n++) { minRWIL = minRWIL.max(calcRWIHFor(index, n)); } @@ -73,7 +73,7 @@ private Num calcRWIHFor(final int index, final int n) { Num low = series.getBar(index).getLowPrice(); Num highN = series.getBar(index + 1 - n).getHighPrice(); Num atrN = new ATRIndicator(series, n).getValue(index); - Num sqrtN = numOf(n).sqrt(); + Num sqrtN = series.numFactory().numOf(n).sqrt(); return highN.minus(low).dividedBy(atrN.multipliedBy(sqrtN)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/SMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/SMAIndicator.java index 704647da4..b617d9b00 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/SMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/SMAIndicator.java @@ -51,13 +51,14 @@ public SMAIndicator(Indicator indicator, int barCount) { @Override protected Num calculate(int index) { - Num sum = zero(); + final var numFactory = getBarSeries().numFactory(); + Num sum = numFactory.zero(); for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { sum = sum.plus(indicator.getValue(i)); } final int realBarCount = Math.min(barCount, index + 1); - return sum.dividedBy(numOf(realBarCount)); + return sum.dividedBy(numFactory.numOf(realBarCount)); } /** @return {@link #barCount} */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/StochasticOscillatorKIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/StochasticOscillatorKIndicator.java index 084cc7535..a78e77c83 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/StochasticOscillatorKIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/StochasticOscillatorKIndicator.java @@ -87,7 +87,7 @@ protected Num calculate(int index) { return indicator.getValue(index) .minus(lowestLowPrice) .dividedBy(highestHighPrice.minus(lowestLowPrice)) - .multipliedBy(hundred()); + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/TripleEMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/TripleEMAIndicator.java index b5023b42f..c10992cda 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/TripleEMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/TripleEMAIndicator.java @@ -62,7 +62,10 @@ public TripleEMAIndicator(Indicator indicator, int barCount) { @Override protected Num calculate(int index) { // trix = 3 * ( ema - emaEma ) + emaEmaEma - return numOf(3).multipliedBy(ema.getValue(index).minus(emaEma.getValue(index))).plus(emaEmaEma.getValue(index)); + final var numFactory = getBarSeries().numFactory(); + return numFactory.numOf(3) + .multipliedBy(ema.getValue(index).minus(emaEma.getValue(index))) + .plus(emaEmaEma.getValue(index)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/UlcerIndexIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/UlcerIndexIndicator.java index 616d7e43c..3026fd4f7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/UlcerIndexIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/UlcerIndexIndicator.java @@ -37,9 +37,6 @@ */ public class UlcerIndexIndicator extends CachedIndicator { - private final Num hundred; - private final Num zero; - private final Indicator indicator; private final int barCount; @@ -53,25 +50,26 @@ public UlcerIndexIndicator(Indicator indicator, int barCount) { super(indicator); this.indicator = indicator; this.barCount = barCount; - this.zero = zero(); - this.hundred = hundred(); } @Override protected Num calculate(int index) { final int startIndex = Math.max(0, index - barCount + 1); final int numberOfObservations = index - startIndex + 1; - Num squaredAverage = zero; + final var numFactory = getBarSeries().numFactory(); + Num squaredAverage = numFactory.zero(); Num highestValue = indicator.getValue(startIndex); for (int i = startIndex; i <= index; i++) { Num currentValue = indicator.getValue(i); if (currentValue.isGreaterThan(highestValue)) { highestValue = currentValue; } - Num percentageDrawdown = currentValue.minus(highestValue).dividedBy(highestValue).multipliedBy(hundred); + Num percentageDrawdown = currentValue.minus(highestValue) + .dividedBy(highestValue) + .multipliedBy(numFactory.hundred()); squaredAverage = squaredAverage.plus(percentageDrawdown.pow(2)); } - squaredAverage = squaredAverage.dividedBy(numOf(numberOfObservations)); + squaredAverage = squaredAverage.dividedBy(numFactory.numOf(numberOfObservations)); return squaredAverage.sqrt(); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/WMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/WMAIndicator.java index 62ec6c946..e38b5622f 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/WMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/WMAIndicator.java @@ -52,15 +52,16 @@ protected Num calculate(int index) { return indicator.getValue(0); } - Num value = zero(); + final var numFactory = getBarSeries().numFactory(); + Num value = numFactory.zero(); int loopLength = (index - barCount < 0) ? index + 1 : barCount; int actualIndex = index; for (int i = loopLength; i > 0; i--) { - value = value.plus(numOf(i).multipliedBy(indicator.getValue(actualIndex))); + value = value.plus(numFactory.numOf(i).multipliedBy(indicator.getValue(actualIndex))); actualIndex--; } - return value.dividedBy(numOf((loopLength * (loopLength + 1)) / 2)); + return value.dividedBy(numFactory.numOf((loopLength * (loopLength + 1)) / 2)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/WilliamsRIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/WilliamsRIndicator.java index 30d231507..a4ec888cc 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/WilliamsRIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/WilliamsRIndicator.java @@ -73,7 +73,7 @@ public WilliamsRIndicator(ClosePriceIndicator closePriceIndicator, int barCount, this.barCount = barCount; this.highPriceIndicator = highPriceIndicator; this.lowPriceIndicator = lowPriceIndicator; - this.multiplier = numOf(-100); + this.multiplier = getBarSeries().numFactory().numOf(-100); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ZLEMAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ZLEMAIndicator.java index d8d11a3ed..707d7446a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ZLEMAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ZLEMAIndicator.java @@ -51,8 +51,8 @@ public ZLEMAIndicator(Indicator indicator, int barCount) { super(indicator); this.indicator = indicator; this.barCount = barCount; - this.two = numOf(2); - this.k = two.dividedBy(numOf(barCount + 1)); + this.two = getBarSeries().numFactory().numOf(2); + this.k = two.dividedBy(getBarSeries().numFactory().numOf(barCount + 1)); this.lag = (barCount - 1) / 2; } @@ -68,7 +68,7 @@ protected Num calculate(int index) { } Num zlemaPrev = getValue(index - 1); return k.multipliedBy(two.multipliedBy(indicator.getValue(index)).minus(indicator.getValue(index - lag))) - .plus(one().minus(k).multipliedBy(zlemaPrev)); + .plus(getBarSeries().numFactory().one().minus(k).multipliedBy(zlemaPrev)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/DXIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/DXIndicator.java index 2d4bd7ca0..f187e20d3 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/DXIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/DXIndicator.java @@ -57,10 +57,13 @@ public DXIndicator(BarSeries series, int barCount) { protected Num calculate(int index) { Num pdiValue = plusDIIndicator.getValue(index); Num mdiValue = minusDIIndicator.getValue(index); - if (pdiValue.plus(mdiValue).equals(zero())) { - return zero(); + if (pdiValue.plus(mdiValue).equals(getBarSeries().numFactory().zero())) { + return getBarSeries().numFactory().zero(); } - return pdiValue.minus(mdiValue).abs().dividedBy(pdiValue.plus(mdiValue)).multipliedBy(hundred()); + return pdiValue.minus(mdiValue) + .abs() + .dividedBy(pdiValue.plus(mdiValue)) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDIIndicator.java index 238a2db24..055af7166 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDIIndicator.java @@ -63,7 +63,9 @@ public MinusDIIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { - return avgMinusDMIndicator.getValue(index).dividedBy(atrIndicator.getValue(index)).multipliedBy(hundred()); + return avgMinusDMIndicator.getValue(index) + .dividedBy(atrIndicator.getValue(index)) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDMIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDMIndicator.java index 8963255c9..b42db424b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDMIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/MinusDMIndicator.java @@ -48,17 +48,17 @@ public MinusDMIndicator(BarSeries series) { @Override protected Num calculate(int index) { if (index == 0) { - return zero(); + return getBarSeries().numFactory().zero(); } final Bar prevBar = getBarSeries().getBar(index - 1); final Bar currentBar = getBarSeries().getBar(index); final Num upMove = currentBar.getHighPrice().minus(prevBar.getHighPrice()); final Num downMove = prevBar.getLowPrice().minus(currentBar.getLowPrice()); - if (downMove.isGreaterThan(upMove) && downMove.isGreaterThan(zero())) { + if (downMove.isGreaterThan(upMove) && downMove.isGreaterThan(getBarSeries().numFactory().zero())) { return downMove; } else { - return numOf(0); + return getBarSeries().numFactory().zero(); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDIIndicator.java index 3bd646547..80a762d2b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDIIndicator.java @@ -63,7 +63,9 @@ public PlusDIIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { - return avgPlusDMIndicator.getValue(index).dividedBy(atrIndicator.getValue(index)).multipliedBy(numOf(100)); + return avgPlusDMIndicator.getValue(index) + .dividedBy(atrIndicator.getValue(index)) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDMIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDMIndicator.java index df6f2136c..1280feec1 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDMIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/adx/PlusDMIndicator.java @@ -47,18 +47,19 @@ public PlusDMIndicator(BarSeries series) { @Override protected Num calculate(int index) { + final var numFactory = getBarSeries().numFactory(); if (index == 0) { - return zero(); + return numFactory.zero(); } final Bar prevBar = getBarSeries().getBar(index - 1); final Bar currentBar = getBarSeries().getBar(index); final Num upMove = currentBar.getHighPrice().minus(prevBar.getHighPrice()); final Num downMove = prevBar.getLowPrice().minus(currentBar.getLowPrice()); - if (upMove.isGreaterThan(downMove) && upMove.isGreaterThan(zero())) { + if (upMove.isGreaterThan(downMove) && upMove.isGreaterThan(numFactory.zero())) { return upMove; } else { - return zero(); + return numFactory.zero(); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonDownIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonDownIndicator.java index a1e7f3f2f..8ea075552 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonDownIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonDownIndicator.java @@ -43,7 +43,6 @@ public class AroonDownIndicator extends CachedIndicator { private final int barCount; private final LowestValueIndicator lowestLowPriceIndicator; private final Indicator lowPriceIndicator; - private final Num hundred; private final Num barCountNum; /** @@ -57,8 +56,7 @@ public AroonDownIndicator(Indicator lowPriceIndicator, int barCount) { super(lowPriceIndicator); this.barCount = barCount; this.lowPriceIndicator = lowPriceIndicator; - this.hundred = hundred(); - this.barCountNum = numOf(barCount); + this.barCountNum = getBarSeries().numFactory().numOf(barCount); // + 1 needed for last possible iteration in loop this.lowestLowPriceIndicator = new LowestValueIndicator(lowPriceIndicator, barCount + 1); } @@ -89,7 +87,9 @@ protected Num calculate(int index) { nbBars++; } - return numOf(barCount - nbBars).dividedBy(barCountNum).multipliedBy(hundred); + // TODO is Num needed? + final var numFactory = getBarSeries().numFactory(); + return numFactory.numOf(barCount - nbBars).dividedBy(barCountNum).multipliedBy(numFactory.hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonUpIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonUpIndicator.java index 16152abb9..1760bf004 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonUpIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/aroon/AroonUpIndicator.java @@ -43,7 +43,6 @@ public class AroonUpIndicator extends CachedIndicator { private final int barCount; private final HighestValueIndicator highestHighPriceIndicator; private final Indicator highPriceIndicator; - private final Num hundred; private final Num barCountNum; /** @@ -57,8 +56,7 @@ public AroonUpIndicator(Indicator highPriceIndicator, int barCount) { super(highPriceIndicator); this.barCount = barCount; this.highPriceIndicator = highPriceIndicator; - this.hundred = hundred(); - this.barCountNum = numOf(barCount); + this.barCountNum = getBarSeries().numFactory().numOf(barCount); // + 1 needed for last possible iteration in loop this.highestHighPriceIndicator = new HighestValueIndicator(highPriceIndicator, barCount + 1); } @@ -89,7 +87,8 @@ protected Num calculate(int index) { nbBars++; } - return numOf(barCount - nbBars).dividedBy(barCountNum).multipliedBy(hundred); + final var numFactory = getBarSeries().numFactory(); + return numFactory.numOf(barCount - nbBars).dividedBy(barCountNum).multipliedBy(numFactory.hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicator.java index 6f630a38b..3ed3b2e6f 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicator.java @@ -38,7 +38,6 @@ public class BollingerBandWidthIndicator extends CachedIndicator { private final BollingerBandsUpperIndicator bbu; private final BollingerBandsMiddleIndicator bbm; private final BollingerBandsLowerIndicator bbl; - private final Num hundred; /** * Constructor. @@ -54,12 +53,14 @@ public BollingerBandWidthIndicator(BollingerBandsUpperIndicator bbu, BollingerBa this.bbu = bbu; this.bbm = bbm; this.bbl = bbl; - this.hundred = bbm.getBarSeries().hundred(); } @Override protected Num calculate(int index) { - return bbu.getValue(index).minus(bbl.getValue(index)).dividedBy(bbm.getValue(index)).multipliedBy(hundred); + return bbu.getValue(index) + .minus(bbl.getValue(index)) + .dividedBy(bbm.getValue(index)) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicator.java index 6d6ba49f0..596e377ec 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicator.java @@ -50,7 +50,7 @@ public class BollingerBandsLowerIndicator extends CachedIndicator { * Typically a {@code StandardDeviationIndicator} is used. */ public BollingerBandsLowerIndicator(BollingerBandsMiddleIndicator bbm, Indicator indicator) { - this(bbm, indicator, bbm.getBarSeries().numOf(2)); + this(bbm, indicator, bbm.getBarSeries().numFactory().numOf(2)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicator.java index d4bb695cd..c1fa3b2f2 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicator.java @@ -50,7 +50,7 @@ public class BollingerBandsUpperIndicator extends CachedIndicator { * Typically a {@code StandardDeviationIndicator} is used. */ public BollingerBandsUpperIndicator(BollingerBandsMiddleIndicator bbm, Indicator deviation) { - this(bbm, deviation, bbm.getBarSeries().numOf(2)); + this(bbm, deviation, bbm.getBarSeries().numFactory().two()); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/PercentBIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/PercentBIndicator.java index 96a4fda52..294ed8913 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/PercentBIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/bollinger/PercentBIndicator.java @@ -54,8 +54,8 @@ public PercentBIndicator(Indicator indicator, int barCount, double k) { this.indicator = indicator; BollingerBandsMiddleIndicator bbm = new BollingerBandsMiddleIndicator(new SMAIndicator(indicator, barCount)); StandardDeviationIndicator sd = new StandardDeviationIndicator(indicator, barCount); - this.bbu = new BollingerBandsUpperIndicator(bbm, sd, numOf(k)); - this.bbl = new BollingerBandsLowerIndicator(bbm, sd, numOf(k)); + this.bbu = new BollingerBandsUpperIndicator(bbm, sd, getBarSeries().numFactory().numOf(k)); + this.bbl = new BollingerBandsLowerIndicator(bbm, sd, getBarSeries().numFactory().numOf(k)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/DojiIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/DojiIndicator.java index da52f4acd..411230388 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/DojiIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/DojiIndicator.java @@ -64,7 +64,7 @@ public DojiIndicator(BarSeries series, int barCount, double bodyFactor) { super(series); this.bodyHeightInd = TransformIndicator.abs(new RealBodyIndicator(series)); this.averageBodyHeightInd = new SMAIndicator(bodyHeightInd, barCount); - this.factor = numOf(bodyFactor); + this.factor = getBarSeries().numFactory().numOf(bodyFactor); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicator.java index 059918023..0a6b5c661 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicator.java @@ -58,7 +58,7 @@ public ThreeBlackCrowsIndicator(BarSeries series, int barCount, double factor) { super(series); this.lowerShadowInd = new LowerShadowIndicator(series); this.averageLowerShadowInd = new SMAIndicator(lowerShadowInd, barCount); - this.factor = numOf(factor); + this.factor = getBarSeries().numFactory().numOf(factor); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicator.java index 649fc8d58..c993dd4e7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicator.java @@ -51,7 +51,8 @@ public DonchianChannelMiddleIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { - return (this.lower.getValue(index).plus(this.upper.getValue(index))).dividedBy(numOf(2)); + return (this.lower.getValue(index).plus(this.upper.getValue(index))) + .dividedBy(getBarSeries().numFactory().two()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicator.java index 43feb9d5d..98ec6faee 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicator.java @@ -36,8 +36,6 @@ */ public class CloseLocationValueIndicator extends CachedIndicator { - private final Num zero; - /** * Constructor. * @@ -45,7 +43,6 @@ public class CloseLocationValueIndicator extends CachedIndicator { */ public CloseLocationValueIndicator(BarSeries series) { super(series); - this.zero = zero(); } @Override @@ -57,7 +54,8 @@ protected Num calculate(int index) { final Num diffHighLow = high.minus(low); - return diffHighLow.isNaN() ? zero : ((close.minus(low)).minus(high.minus(close))).dividedBy(diffHighLow); + return diffHighLow.isNaN() ? getBarSeries().numFactory().zero() + : ((close.minus(low)).minus(high.minus(close))).dividedBy(diffHighLow); } /** @return {@code 0} */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicator.java index fd8fd8dda..3b962ea3f 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicator.java @@ -171,8 +171,8 @@ public ConvergenceDivergenceIndicator(Indicator ref, Indicator other, this.barCount = barCount; this.type = type; this.strictType = null; - this.minStrength = numOf(Math.min(1, Math.abs(minStrength))); - this.minSlope = numOf(minSlope); + this.minStrength = getBarSeries().numFactory().numOf(Math.min(1, Math.abs(minStrength))); + this.minSlope = getBarSeries().numFactory().numOf(minSlope); } /** @@ -185,14 +185,7 @@ public ConvergenceDivergenceIndicator(Indicator ref, Indicator other, */ public ConvergenceDivergenceIndicator(Indicator ref, Indicator other, int barCount, ConvergenceDivergenceType type) { - super(ref); - this.ref = ref; - this.other = other; - this.barCount = barCount; - this.type = type; - this.strictType = null; - this.minStrength = numOf(0.8).abs(); - this.minSlope = numOf(0.3); + this(ref, other, barCount, type, 0.8, 0.3); } /** @@ -328,7 +321,8 @@ private Boolean calculateNegativeConvergence(int index) { boolean isConvergent = cc.getValue(index).isGreaterThanOrEqual(minStrength); Num slope = calculateSlopeRel(index); - boolean isNegative = slope.isLessThanOrEqual(minSlope.abs().multipliedBy(numOf(-1))); + boolean isNegative = slope + .isLessThanOrEqual(minSlope.abs().multipliedBy(getBarSeries().numFactory().minusOne())); return isConvergent && isNegative; } @@ -340,7 +334,8 @@ private Boolean calculateNegativeConvergence(int index) { private Boolean calculatePositiveDivergence(int index) { CorrelationCoefficientIndicator cc = new CorrelationCoefficientIndicator(ref, other, barCount); - boolean isDivergent = cc.getValue(index).isLessThanOrEqual(minStrength.multipliedBy(numOf(-1))); + boolean isDivergent = cc.getValue(index) + .isLessThanOrEqual(minStrength.multipliedBy(getBarSeries().numFactory().minusOne())); if (isDivergent) { // If "isDivergent" and "ref" is positive, then "other" must be negative. @@ -358,12 +353,13 @@ private Boolean calculatePositiveDivergence(int index) { private Boolean calculateNegativeDivergence(int index) { CorrelationCoefficientIndicator cc = new CorrelationCoefficientIndicator(ref, other, barCount); - boolean isDivergent = cc.getValue(index).isLessThanOrEqual(minStrength.multipliedBy(numOf(-1))); + boolean isDivergent = cc.getValue(index) + .isLessThanOrEqual(minStrength.multipliedBy(getBarSeries().numFactory().numOf(-1))); if (isDivergent) { // If "isDivergent" and "ref" is positive, then "other" must be negative. Num slope = calculateSlopeRel(index); - return slope.isLessThanOrEqual(minSlope.abs().multipliedBy(numOf(-1))); + return slope.isLessThanOrEqual(minSlope.abs().multipliedBy(getBarSeries().numFactory().numOf(-1))); } return false; diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicator.java index 1da9a96c7..296334b0a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicator.java @@ -41,7 +41,6 @@ public class DifferencePercentageIndicator extends CachedIndicator { private final Indicator indicator; private final Num percentageThreshold; - private final Num hundred; private Num lastNotification; /** @@ -50,7 +49,7 @@ public class DifferencePercentageIndicator extends CachedIndicator { * @param indicator the {@link Indicator} */ public DifferencePercentageIndicator(Indicator indicator) { - this(indicator, indicator.zero()); + this(indicator, indicator.getBarSeries().numFactory().zero()); } /** @@ -60,7 +59,7 @@ public DifferencePercentageIndicator(Indicator indicator) { * @param percentageThreshold the threshold percentage */ public DifferencePercentageIndicator(Indicator indicator, Number percentageThreshold) { - this(indicator, indicator.numOf(percentageThreshold)); + this(indicator, indicator.getBarSeries().numFactory().numOf(percentageThreshold)); } /** @@ -73,7 +72,6 @@ public DifferencePercentageIndicator(Indicator indicator, Num percentageThr super(indicator); this.indicator = indicator; this.percentageThreshold = percentageThreshold; - this.hundred = hundred(); } @Override @@ -125,6 +123,7 @@ public int getUnstableBars() { } private Num fractionToPercentage(Num changeFraction) { + final var hundred = getBarSeries().numFactory().hundred(); return changeFraction.multipliedBy(hundred).minus(hundred); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/FixedDecimalIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/FixedDecimalIndicator.java index d3ebfe21b..acc6dd903 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/FixedDecimalIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/FixedDecimalIndicator.java @@ -45,7 +45,7 @@ public class FixedDecimalIndicator extends FixedIndicator { public FixedDecimalIndicator(BarSeries series, double... values) { super(series); for (double value : values) { - addValue(numOf(value)); + addValue(getBarSeries().numFactory().numOf(value)); } } @@ -58,7 +58,7 @@ public FixedDecimalIndicator(BarSeries series, double... values) { public FixedDecimalIndicator(BarSeries series, String... values) { super(series); for (String value : values) { - addValue(numOf(new BigDecimal(value))); + addValue(getBarSeries().numFactory().numOf(new BigDecimal(value))); } } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/GainIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/GainIndicator.java index ce6fc6392..596500986 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/GainIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/GainIndicator.java @@ -52,11 +52,12 @@ public GainIndicator(Indicator indicator) { @Override protected Num calculate(int index) { if (index == 0) { - return zero(); + return getBarSeries().numFactory().zero(); } Num actualValue = indicator.getValue(index); Num previousValue = indicator.getValue(index - 1); - return actualValue.isGreaterThan(previousValue) ? actualValue.minus(previousValue) : zero(); + return actualValue.isGreaterThan(previousValue) ? actualValue.minus(previousValue) + : getBarSeries().numFactory().zero(); } /** @return {@code 1} */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LossIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LossIndicator.java index 9b3926cab..ce9739d3c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LossIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LossIndicator.java @@ -52,11 +52,12 @@ public LossIndicator(Indicator indicator) { @Override protected Num calculate(int index) { if (index == 0) { - return zero(); + return getBarSeries().numFactory().zero(); } Num actualValue = indicator.getValue(index); Num previousValue = indicator.getValue(index - 1); - return actualValue.isLessThan(previousValue) ? previousValue.minus(actualValue) : zero(); + return actualValue.isLessThan(previousValue) ? previousValue.minus(actualValue) + : getBarSeries().numFactory().zero(); } /** @return {@code 1} */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LowestValueIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LowestValueIndicator.java index be635f684..d156edaae 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LowestValueIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/LowestValueIndicator.java @@ -55,6 +55,9 @@ protected Num calculate(int index) { if (indicator.getValue(index).isNaN() && barCount != 1) { return new LowestValueIndicator(indicator, barCount - 1).getValue(index - 1); } + + // TODO optimize algorithm, compare previous minimum with current value without + // looping int end = Math.max(0, index - barCount + 1); Num lowest = indicator.getValue(index); for (int i = index - 1; i >= end; i--) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/MedianPriceIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/MedianPriceIndicator.java index 6d19ab6bb..2468b7651 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/MedianPriceIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/MedianPriceIndicator.java @@ -52,7 +52,7 @@ public MedianPriceIndicator(BarSeries series) { @Override protected Num calculate(int index) { final Bar bar = getBarSeries().getBar(index); - return bar.getHighPrice().plus(bar.getLowPrice()).dividedBy(numOf(2)); + return bar.getHighPrice().plus(bar.getLowPrice()).dividedBy(getBarSeries().numFactory().two()); } /** @return {@code 0} */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/RunningTotalIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/RunningTotalIndicator.java index d36cfb535..0f0fd48fa 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/RunningTotalIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/RunningTotalIndicator.java @@ -45,7 +45,7 @@ public RunningTotalIndicator(Indicator indicator, int barCount) { @Override protected Num calculate(int index) { - Num sum = zero(); + Num sum = getBarSeries().numFactory().zero(); for (int i = Math.max(getBarSeries().getBeginIndex(), index - barCount + 1); i <= index; i++) { sum = sum.plus(indicator.getValue(i)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/SumIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/SumIndicator.java index bbb4f8cb1..3a03f583a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/SumIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/SumIndicator.java @@ -52,7 +52,7 @@ public SumIndicator(Indicator... summands) { @Override protected Num calculate(int index) { - Num sum = zero(); + Num sum = getBarSeries().numFactory().zero(); for (Indicator summand : summands) { sum = sum.plus(summand.getValue(index)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java index 45bc3268d..dcff1a6c3 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java @@ -71,7 +71,7 @@ public int getUnstableBars() { * Transforms the input indicator by indicator.plus(coefficient). */ public static TransformIndicator plus(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.plus(numCoefficient)); } @@ -79,7 +79,7 @@ public static TransformIndicator plus(Indicator indicator, Number coefficie * Transforms the input indicator by indicator.minus(coefficient). */ public static TransformIndicator minus(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.minus(numCoefficient)); } @@ -87,7 +87,7 @@ public static TransformIndicator minus(Indicator indicator, Number coeffici * Transforms the input indicator by indicator.dividedBy(coefficient). */ public static TransformIndicator divide(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.dividedBy(numCoefficient)); } @@ -95,7 +95,7 @@ public static TransformIndicator divide(Indicator indicator, Number coeffic * Transforms the input indicator by indicator.multipliedBy(coefficient). */ public static TransformIndicator multiply(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.multipliedBy(numCoefficient)); } @@ -103,7 +103,7 @@ public static TransformIndicator multiply(Indicator indicator, Number coeff * Transforms the input indicator by indicator.max(coefficient). */ public static TransformIndicator max(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.max(numCoefficient)); } @@ -111,7 +111,7 @@ public static TransformIndicator max(Indicator indicator, Number coefficien * Transforms the input indicator by indicator.min(coefficient). */ public static TransformIndicator min(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.min(numCoefficient)); } @@ -126,7 +126,7 @@ public static TransformIndicator abs(Indicator indicator) { * Transforms the input indicator by indicator.pow(coefficient). */ public static TransformIndicator pow(Indicator indicator, Number coefficient) { - Num numCoefficient = indicator.numOf(coefficient); + Num numCoefficient = indicator.getBarSeries().numFactory().numOf(coefficient); return new TransformIndicator(indicator, val -> val.pow(numCoefficient)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicator.java index cd5d6bca4..481a5ab2c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicator.java @@ -55,7 +55,7 @@ protected Num calculate(int index) { final Num highPrice = bar.getHighPrice(); final Num lowPrice = bar.getLowPrice(); final Num closePrice = bar.getClosePrice(); - return highPrice.plus(lowPrice).plus(closePrice).dividedBy(numOf(3)); + return highPrice.plus(lowPrice).plus(closePrice).dividedBy(getBarSeries().numFactory().three()); } /** @return {@code 0} */ @@ -63,4 +63,4 @@ protected Num calculate(int index) { public int getUnstableBars() { return 0; } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/VolumeIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/VolumeIndicator.java index 0197bd13b..5f75aea41 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/VolumeIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/VolumeIndicator.java @@ -60,8 +60,9 @@ public VolumeIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { + // TODO use partial sums int startIndex = Math.max(0, index - barCount + 1); - Num sumOfVolume = zero(); + Num sumOfVolume = getBarSeries().numFactory().zero(); for (int i = startIndex; i <= index; i++) { sumOfVolume = sumOfVolume.plus(getBarSeries().getBar(i).getVolume()); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuLineIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuLineIndicator.java index 865abdd26..f555d4e21 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuLineIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuLineIndicator.java @@ -61,7 +61,9 @@ public IchimokuLineIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { - return periodHigh.getValue(index).plus(periodLow.getValue(index)).dividedBy(numOf(2)); + return periodHigh.getValue(index) + .plus(periodLow.getValue(index)) + .dividedBy(getBarSeries().numFactory().numOf(2)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuSenkouSpanAIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuSenkouSpanAIndicator.java index 223d00343..9288d7bf1 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuSenkouSpanAIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/ichimoku/IchimokuSenkouSpanAIndicator.java @@ -89,7 +89,9 @@ protected Num calculate(int index) { // at index=7 we need index=3 when offset=5 int spanIndex = index - offset + 1; if (spanIndex >= getBarSeries().getBeginIndex()) { - return conversionLine.getValue(spanIndex).plus(baseLine.getValue(spanIndex)).dividedBy(numOf(2)); + return conversionLine.getValue(spanIndex) + .plus(baseLine.getValue(spanIndex)) + .dividedBy(getBarSeries().numFactory().two()); } else { return NaN.NaN; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicator.java index b2ba2a04b..1d76ffb59 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicator.java @@ -62,7 +62,7 @@ public KeltnerChannelLowerIndicator(KeltnerChannelMiddleIndicator middle, ATRInd super(middle.getBarSeries()); this.keltnerMiddleIndicator = middle; this.averageTrueRangeIndicator = atr; - this.ratio = numOf(ratio); + this.ratio = getBarSeries().numFactory().numOf(ratio); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicator.java index 5e76c591f..cc39d0e41 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicator.java @@ -62,7 +62,7 @@ public KeltnerChannelUpperIndicator(KeltnerChannelMiddleIndicator middle, ATRInd super(middle.getBarSeries()); this.keltnerMiddleIndicator = middle; this.averageTrueRangeIndicator = atr; - this.ratio = numOf(ratio); + this.ratio = getBarSeries().numFactory().numOf(ratio); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/numeric/NumericIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/numeric/NumericIndicator.java index a147d3b3c..da9a1c572 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/numeric/NumericIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/numeric/NumericIndicator.java @@ -353,7 +353,7 @@ public Rule isLessThan(Number n) { } private Indicator createConstant(Number n) { - return new ConstantIndicator<>(getBarSeries(), numOf(n)); + return new ConstantIndicator<>(getBarSeries(), getBarSeries().numFactory().numOf(n)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkPivotPointIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkPivotPointIndicator.java index 5e2f6ac95..25a9ba50e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkPivotPointIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkPivotPointIndicator.java @@ -81,8 +81,8 @@ public class DeMarkPivotPointIndicator extends RecursiveCachedIndicator { public DeMarkPivotPointIndicator(BarSeries series, TimeLevel timeLevelId) { super(series); this.timeLevel = timeLevelId; - this.two = numOf(2); - this.four = numOf(4); + this.two = getBarSeries().numFactory().two(); + this.four = getBarSeries().numFactory().numOf(4); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkReversalIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkReversalIndicator.java index 15f5cf2b4..3ae2f7705 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkReversalIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/DeMarkReversalIndicator.java @@ -42,7 +42,6 @@ public class DeMarkReversalIndicator extends RecursiveCachedIndicator { private final DeMarkPivotPointIndicator pivotPointIndicator; private final DeMarkPivotLevel level; - private final Num two; public enum DeMarkPivotLevel { RESISTANCE, SUPPORT, @@ -62,12 +61,11 @@ public DeMarkReversalIndicator(DeMarkPivotPointIndicator pivotPointIndicator, De super(pivotPointIndicator); this.pivotPointIndicator = pivotPointIndicator; this.level = level; - this.two = numOf(2); } @Override protected Num calculate(int index) { - Num x = pivotPointIndicator.getValue(index).multipliedBy(numOf(4)); + Num x = pivotPointIndicator.getValue(index).multipliedBy(getBarSeries().numFactory().numOf(4)); Num result; if (level == DeMarkPivotLevel.SUPPORT) { @@ -95,7 +93,7 @@ private Num calculateResistance(Num x, int index) { low = getBarSeries().getBar(i).getLowPrice().min(low); } - return x.dividedBy(two).minus(low); + return x.dividedBy(getBarSeries().numFactory().two()).minus(low); } private Num calculateSupport(Num x, int index) { @@ -109,6 +107,6 @@ private Num calculateSupport(Num x, int index) { high = getBarSeries().getBar(i).getHighPrice().max(high); } - return x.dividedBy(two).minus(high); + return x.dividedBy(getBarSeries().numFactory().two()).minus(high); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/FibonacciReversalIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/FibonacciReversalIndicator.java index c90f7c4e1..b6f5bca00 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/FibonacciReversalIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/FibonacciReversalIndicator.java @@ -80,7 +80,7 @@ public FibonacciReversalIndicator(PivotPointIndicator pivotPointIndicator, doubl FibReversalTyp fibReversalTyp) { super(pivotPointIndicator); this.pivotPointIndicator = pivotPointIndicator; - this.fibonacciFactor = numOf(fibonacciFactor); + this.fibonacciFactor = getBarSeries().numFactory().numOf(fibonacciFactor); this.fibReversalTyp = fibReversalTyp; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicator.java index 034104630..695d9dcd4 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicator.java @@ -77,7 +77,7 @@ public class PivotPointIndicator extends RecursiveCachedIndicator { public PivotPointIndicator(BarSeries series, TimeLevel timeLevel) { super(series); this.timeLevel = timeLevel; - this.three = series.numOf(3); + this.three = series.numFactory().numOf(3); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/StandardReversalIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/StandardReversalIndicator.java index e6735069c..e1da9b478 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/StandardReversalIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/pivotpoints/StandardReversalIndicator.java @@ -56,7 +56,7 @@ public StandardReversalIndicator(PivotPointIndicator pivotPointIndicator, PivotL super(pivotPointIndicator); this.pivotPointIndicator = pivotPointIndicator; this.level = level; - this.two = pivotPointIndicator.numOf(2); + this.two = pivotPointIndicator.getBarSeries().numFactory().numOf(2); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/CovarianceIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/CovarianceIndicator.java index afece1a38..ec2c1f11c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/CovarianceIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/CovarianceIndicator.java @@ -59,14 +59,14 @@ public CovarianceIndicator(Indicator indicator1, Indicator indicator2, protected Num calculate(int index) { final int startIndex = Math.max(0, index - barCount + 1); final int numberOfObservations = index - startIndex + 1; - Num covariance = zero(); + Num covariance = getBarSeries().numFactory().zero(); Num average1 = sma1.getValue(index); Num average2 = sma2.getValue(index); for (int i = startIndex; i <= index; i++) { Num mul = indicator1.getValue(i).minus(average1).multipliedBy(indicator2.getValue(i).minus(average2)); covariance = covariance.plus(mul); } - covariance = covariance.dividedBy(numOf(numberOfObservations)); + covariance = covariance.dividedBy(getBarSeries().numFactory().numOf(numberOfObservations)); return covariance; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicator.java index 8b0e9729c..f5dd46b8c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicator.java @@ -56,7 +56,7 @@ public MeanDeviationIndicator(Indicator indicator, int barCount) { @Override protected Num calculate(int index) { - Num absoluteDeviations = zero(); + Num absoluteDeviations = getBarSeries().numFactory().zero(); final Num average = sma.getValue(index); final int startIndex = Math.max(0, index - barCount + 1); @@ -66,7 +66,7 @@ protected Num calculate(int index) { // For each period... absoluteDeviations = absoluteDeviations.plus(indicator.getValue(i).minus(average).abs()); } - return absoluteDeviations.dividedBy(numOf(nbValues)); + return absoluteDeviations.dividedBy(getBarSeries().numFactory().numOf(nbValues)); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicator.java index d420daf19..3a47a457b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicator.java @@ -59,9 +59,10 @@ public PearsonCorrelationIndicator(Indicator indicator1, Indicator ind @Override protected Num calculate(int index) { - Num n = numOf(barCount); + final var numFactory = getBarSeries().numFactory(); + Num n = numFactory.numOf(barCount); - Num zero = zero(); + Num zero = numFactory.zero(); Num Sx = zero; Num Sy = zero; Num Sxx = zero; @@ -84,7 +85,7 @@ protected Num calculate(int index) { Num toSqrt = (n.multipliedBy(Sxx).minus(Sx.multipliedBy(Sx))) .multipliedBy(n.multipliedBy(Syy).minus(Sy.multipliedBy(Sy))); - if (toSqrt.isGreaterThan(zero())) { + if (toSqrt.isGreaterThan(numFactory.zero())) { // pearson = (n * Sxy - Sx * Sy) / sqrt((n * Sxx - Sx * Sx) * (n * Syy - Sy * // Sy)) return (n.multipliedBy(Sxy).minus(Sx.multipliedBy(Sy))).dividedBy(toSqrt.sqrt()); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicator.java index e026d2ebf..5ed2c7dfc 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicator.java @@ -79,7 +79,7 @@ public PeriodicalGrowthRateIndicator(Indicator indicator, int barCount) { super(indicator); this.indicator = indicator; this.barCount = barCount; - this.one = one(); + this.one = getBarSeries().numFactory().one(); } /** @@ -107,7 +107,7 @@ public Num getTotalReturn() { } } - return totalProduct.pow(one.dividedBy(numOf(completeTimeFrames))); + return totalProduct.pow(one.dividedBy(getBarSeries().numFactory().numOf(completeTimeFrames))); } @Override @@ -117,11 +117,13 @@ protected Num calculate(int index) { int helpPartialTimeframe = index % barCount; // TODO: implement Num.floor() - Num helpFullTimeframes = numOf( - Math.floor(numOf(indicator.getBarSeries().getBarCount()).dividedBy(numOf(barCount)).doubleValue())); - Num helpIndexTimeframes = numOf(index).dividedBy(numOf(barCount)); + final var numFactory = getBarSeries().numFactory(); + Num helpFullTimeframes = numFactory.numOf(Math.floor(numFactory.numOf(indicator.getBarSeries().getBarCount()) + .dividedBy(numFactory.numOf(barCount)) + .doubleValue())); + Num helpIndexTimeframes = numFactory.numOf(index).dividedBy(numFactory.numOf(barCount)); - Num helpPartialTimeframeHeld = numOf(helpPartialTimeframe).dividedBy(numOf(barCount)); + Num helpPartialTimeframeHeld = numFactory.numOf(helpPartialTimeframe).dividedBy(numFactory.numOf(barCount)); Num partialTimeframeHeld = (helpPartialTimeframeHeld.isZero()) ? one : helpPartialTimeframeHeld; // Avoid calculations of returns: diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicator.java index 22025c8f5..9ec22fb2b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicator.java @@ -39,7 +39,8 @@ * y = slope * x + intercept * * - * @see http://introcs.cs.princeton.edu/java/97data/LinearRegression.java.html + * see LinearRegression */ public class SimpleLinearRegressionIndicator extends CachedIndicator { @@ -97,7 +98,7 @@ protected Num calculate(int index) { return intercept; } - return slope.multipliedBy(numOf(index)).plus(intercept); + return slope.multipliedBy(getBarSeries().numFactory().numOf(index)).plus(intercept); } @Override @@ -112,15 +113,16 @@ public int getUnstableBars() { * @param endIndex the end index (inclusive) in the bar series */ private void calculateRegressionLine(int startIndex, int endIndex) { - Num zero = zero(); + final var numFactory = getBarSeries().numFactory(); + Num zero = numFactory.zero(); // First pass: compute xBar and yBar Num sumX = zero; Num sumY = zero; for (int i = startIndex; i <= endIndex; i++) { - sumX = sumX.plus(numOf(i)); + sumX = sumX.plus(numFactory.numOf(i)); sumY = sumY.plus(indicator.getValue(i)); } - Num nbObservations = numOf(endIndex - startIndex + 1); + Num nbObservations = numFactory.numOf(endIndex - startIndex + 1); Num xBar = sumX.dividedBy(nbObservations); Num yBar = sumY.dividedBy(nbObservations); @@ -128,7 +130,7 @@ private void calculateRegressionLine(int startIndex, int endIndex) { Num xxBar = zero; Num xyBar = zero; for (int i = startIndex; i <= endIndex; i++) { - Num dX = numOf(i).minus(xBar); + Num dX = numFactory.numOf(i).minus(xBar); Num dY = indicator.getValue(i).minus(yBar); xxBar = xxBar.plus(dX.multipliedBy(dX)); xyBar = xyBar.plus(dX.multipliedBy(dY)); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/StandardErrorIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/StandardErrorIndicator.java index 4ab0181c3..5b1a63940 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/StandardErrorIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/StandardErrorIndicator.java @@ -51,7 +51,7 @@ public StandardErrorIndicator(Indicator indicator, int barCount) { protected Num calculate(int index) { final int startIndex = Math.max(0, index - barCount + 1); final int numberOfObservations = index - startIndex + 1; - return sdev.getValue(index).dividedBy(numOf(numberOfObservations).sqrt()); + return sdev.getValue(index).dividedBy(getBarSeries().numFactory().numOf(numberOfObservations).sqrt()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/VarianceIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/VarianceIndicator.java index c32997f27..26d2dbec0 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/VarianceIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/statistics/VarianceIndicator.java @@ -54,13 +54,14 @@ public VarianceIndicator(Indicator indicator, int barCount) { protected Num calculate(int index) { final int startIndex = Math.max(0, index - barCount + 1); final int numberOfObservations = index - startIndex + 1; - Num variance = zero(); + final var numFactory = getBarSeries().numFactory(); + Num variance = numFactory.zero(); Num average = sma.getValue(index); for (int i = startIndex; i <= index; i++) { Num pow = indicator.getValue(i).minus(average).pow(2); variance = variance.plus(pow); } - variance = variance.dividedBy(numOf(numberOfObservations)); + variance = variance.dividedBy(numFactory.numOf(numberOfObservations)); return variance; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicator.java index e10a0d403..05174c6a0 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicator.java @@ -34,7 +34,6 @@ */ public class SuperTrendIndicator extends RecursiveCachedIndicator { - private final Num ZERO = zero(); private final SuperTrendUpperBandIndicator superTrendUpperBandIndicator; private final SuperTrendLowerBandIndicator superTrendLowerBandIndicator; @@ -65,9 +64,10 @@ public SuperTrendIndicator(final BarSeries series, int barCount, final Double mu @Override protected Num calculate(int i) { - Num value = ZERO; - if (i == 0) + Num value = getBarSeries().numFactory().zero(); + if (i == 0) { return value; + } Bar bar = getBarSeries().getBar(i); Num closePrice = bar.getClosePrice(); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicator.java index 459b93a3f..daf21d9eb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicator.java @@ -59,14 +59,15 @@ public SuperTrendLowerBandIndicator(final BarSeries barSeries, final ATRIndicato final Double multiplier) { super(barSeries); this.atrIndicator = atrIndicator; - this.multiplier = numOf(multiplier); + this.multiplier = getBarSeries().numFactory().numOf(multiplier); this.medianPriceIndicator = new MedianPriceIndicator(barSeries); } @Override protected Num calculate(int index) { - if (index == 0) - return zero(); + if (index == 0) { + return getBarSeries().numFactory().zero(); + } Bar bar = getBarSeries().getBar(index - 1); Num previousValue = this.getValue(index - 1); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicator.java index b537b6308..7a8faf1e1 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicator.java @@ -59,7 +59,7 @@ public SuperTrendUpperBandIndicator(final BarSeries barSeries, final ATRIndicato final Double multiplier) { super(barSeries); this.atrIndicator = atrIndicator; - this.multiplier = numOf(multiplier); + this.multiplier = getBarSeries().numFactory().numOf(multiplier); this.medianPriceIndicator = new MedianPriceIndicator(barSeries); } @@ -67,8 +67,9 @@ public SuperTrendUpperBandIndicator(final BarSeries barSeries, final ATRIndicato protected Num calculate(int index) { Num currentBasic = medianPriceIndicator.getValue(index) .plus(multiplier.multipliedBy(atrIndicator.getValue(index))); - if (index == 0) + if (index == 0) { return currentBasic; + } Bar bar = getBarSeries().getBar(index - 1); Num previousValue = this.getValue(index - 1); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicator.java index 24a572f0c..fb2030147 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicator.java @@ -48,7 +48,7 @@ public AccumulationDistributionIndicator(BarSeries series) { @Override protected Num calculate(int index) { if (index == 0) { - return zero(); + return getBarSeries().numFactory().zero(); } // Calculating the money flow multiplier diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicator.java index e474d420a..f7b7a978b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicator.java @@ -61,7 +61,7 @@ public ChaikinMoneyFlowIndicator(BarSeries series, int barCount) { @Override protected Num calculate(int index) { int startIndex = Math.max(0, index - barCount + 1); - Num sumOfMoneyFlowVolume = zero(); + Num sumOfMoneyFlowVolume = getBarSeries().numFactory().zero(); for (int i = startIndex; i <= index; i++) { sumOfMoneyFlowVolume = sumOfMoneyFlowVolume.plus(getMoneyFlowVolume(i)); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/IIIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/IIIIndicator.java index 92d290654..e66bbcab7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/IIIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/IIIIndicator.java @@ -43,7 +43,6 @@ public class IIIIndicator extends CachedIndicator { private final HighPriceIndicator highPriceIndicator; private final LowPriceIndicator lowPriceIndicator; private final VolumeIndicator volumeIndicator; - private final Num two; /** * Constructor. @@ -56,15 +55,16 @@ public IIIIndicator(BarSeries series) { this.highPriceIndicator = new HighPriceIndicator(series); this.lowPriceIndicator = new LowPriceIndicator(series); this.volumeIndicator = new VolumeIndicator(series); - this.two = numOf(2); } @Override protected Num calculate(int index) { if (index == getBarSeries().getBeginIndex()) { - return zero(); + return getBarSeries().numFactory().zero(); } - final Num doubledClosePrice = two.multipliedBy(closePriceIndicator.getValue(index)); + final Num doubledClosePrice = getBarSeries().numFactory() + .two() + .multipliedBy(closePriceIndicator.getValue(index)); final Num high = highPriceIndicator.getValue(index); final Num low = lowPriceIndicator.getValue(index); final Num highMinusLow = high.minus(low); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicator.java index 1329d0257..12ea78e3a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicator.java @@ -23,6 +23,8 @@ */ package org.ta4j.core.indicators.volume; +import static org.ta4j.core.num.NaN.NaN; + import org.ta4j.core.BarSeries; import org.ta4j.core.indicators.CachedIndicator; import org.ta4j.core.indicators.helpers.PreviousValueIndicator; @@ -30,8 +32,6 @@ import org.ta4j.core.indicators.helpers.VolumeIndicator; import org.ta4j.core.num.Num; -import static org.ta4j.core.num.NaN.NaN; - /** * Money Flow Index (MFI) indicator. *

@@ -71,8 +71,9 @@ protected Num calculate(int index) { return NaN; } - Num sumOfPositiveMoneyFlowVolume = zero(); - Num sumOfNegativeMoneyFlowVolume = zero(); + final var numFactory = getBarSeries().numFactory(); + Num sumOfPositiveMoneyFlowVolume = numFactory.zero(); + Num sumOfNegativeMoneyFlowVolume = numFactory.zero(); // Start from the first bar or the start of the window int startIndex = Math.max(0, index - barCount + 1); @@ -94,10 +95,11 @@ else if (currentTypicalPriceValue.isLessThan(previousTypicalPriceValue)) { } // Calculate money flow ratio and index - Num moneyFlowRatio = sumOfPositiveMoneyFlowVolume.max(one()).dividedBy(sumOfNegativeMoneyFlowVolume.max(one())); + Num moneyFlowRatio = sumOfPositiveMoneyFlowVolume.max(numFactory.one()) + .dividedBy(sumOfNegativeMoneyFlowVolume.max(numFactory.one())); // Calculate MFI. max function is used to prevent division by zero. - return hundred().minus((hundred().dividedBy((one().plus(moneyFlowRatio))))); + return numFactory.hundred().minus((numFactory.hundred().dividedBy((numFactory.one().plus(moneyFlowRatio))))); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/NVIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/NVIIndicator.java index 001fe0194..55b810269 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/NVIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/NVIIndicator.java @@ -54,7 +54,7 @@ public NVIIndicator(BarSeries series) { @Override protected Num calculate(int index) { if (index == 0) { - return numOf(1000); + return getBarSeries().numFactory().thousand(); } Bar currentBar = getBarSeries().getBar(index); @@ -75,4 +75,4 @@ public int getUnstableBars() { return 0; } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicator.java index ed7f1f406..a0b4c2430 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicator.java @@ -47,7 +47,7 @@ public OnBalanceVolumeIndicator(BarSeries series) { @Override protected Num calculate(int index) { if (index == 0) { - return zero(); + return getBarSeries().numFactory().zero(); } final Num prevClose = getBarSeries().getBar(index - 1).getClosePrice(); final Num currentClose = getBarSeries().getBar(index).getClosePrice(); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/PVIIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/PVIIndicator.java index 2fefb38ab..1e6469e8d 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/PVIIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/PVIIndicator.java @@ -51,7 +51,7 @@ public PVIIndicator(BarSeries series) { @Override protected Num calculate(int index) { if (index == 0) { - return numOf(1000); + return getBarSeries().numFactory().thousand(); } Bar currentBar = getBarSeries().getBar(index); @@ -72,4 +72,4 @@ public int getUnstableBars() { return 0; } -} \ No newline at end of file +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ROCVIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ROCVIndicator.java index e9d918817..b5f2e3aab 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ROCVIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/ROCVIndicator.java @@ -38,7 +38,6 @@ public class ROCVIndicator extends CachedIndicator { private final int barCount; - private final Num hundred; /** * Constructor. @@ -49,7 +48,6 @@ public class ROCVIndicator extends CachedIndicator { public ROCVIndicator(BarSeries series, int barCount) { super(series); this.barCount = barCount; - this.hundred = hundred(); } @Override @@ -57,7 +55,9 @@ protected Num calculate(int index) { int nIndex = Math.max(index - barCount, 0); Num nPeriodsAgoValue = getBarSeries().getBar(nIndex).getVolume(); Num currentValue = getBarSeries().getBar(index).getVolume(); - return currentValue.minus(nPeriodsAgoValue).dividedBy(nPeriodsAgoValue).multipliedBy(hundred); + return currentValue.minus(nPeriodsAgoValue) + .dividedBy(nPeriodsAgoValue) + .multipliedBy(getBarSeries().numFactory().hundred()); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicator.java index f954ec0d5..c4463d109 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicator.java @@ -23,14 +23,13 @@ */ package org.ta4j.core.indicators.volume; +import static org.ta4j.core.num.NaN.NaN; + import org.ta4j.core.BarSeries; import org.ta4j.core.indicators.CachedIndicator; import org.ta4j.core.indicators.helpers.ClosePriceDifferenceIndicator; -import org.ta4j.core.indicators.helpers.VolumeIndicator; import org.ta4j.core.num.Num; -import static org.ta4j.core.num.NaN.NaN; - /** * Time Segmented Volume (TSV) indicator. * @@ -69,7 +68,7 @@ protected Num calculate(int index) { return NaN; } - Num tsv = zero(); + Num tsv = getBarSeries().numFactory().zero(); // Calculate the TSV for the given period int startIndex = Math.max(0, index - barCount + 1); diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/VWAPIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/VWAPIndicator.java index 9cefd46e6..0fb36ded0 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/VWAPIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/volume/VWAPIndicator.java @@ -47,7 +47,6 @@ public class VWAPIndicator extends CachedIndicator { private final int barCount; private final Indicator typicalPrice; private final Indicator volume; - private final Num zero; /** * Constructor. @@ -60,7 +59,6 @@ public VWAPIndicator(BarSeries series, int barCount) { this.barCount = barCount; this.typicalPrice = new TypicalPriceIndicator(series); this.volume = new VolumeIndicator(series); - this.zero = zero(); } @Override @@ -69,6 +67,7 @@ protected Num calculate(int index) { return typicalPrice.getValue(index); } int startIndex = Math.max(0, index - barCount + 1); + final var zero = getBarSeries().numFactory().zero(); Num cumulativeTPV = zero; Num cumulativeVolume = zero; for (int i = startIndex; i <= index; i++) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java index 0a681e72d..5ae22ed83 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java @@ -54,9 +54,13 @@ public final class DecimalNum implements Num { private static final int DEFAULT_PRECISION = 32; private static final Logger log = LoggerFactory.getLogger(DecimalNum.class); + public static final DecimalNum MINUS_ONE = DecimalNum.valueOf(-1); public static final DecimalNum ZERO = DecimalNum.valueOf(0); - private static final DecimalNum ONE = DecimalNum.valueOf(1); - private static final DecimalNum HUNDRED = DecimalNum.valueOf(100); + public static final DecimalNum ONE = DecimalNum.valueOf(1); + public static final DecimalNum TWO = DecimalNum.valueOf(2); + public static final DecimalNum THREE = DecimalNum.valueOf(3); + public static final DecimalNum HUNDRED = DecimalNum.valueOf(100); + public static final DecimalNum THOUSAND = DecimalNum.valueOf(1000); private final MathContext mathContext; private final BigDecimal delegate; diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java new file mode 100644 index 000000000..70be5c49f --- /dev/null +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java @@ -0,0 +1,71 @@ +/** +* The MIT License (MIT) +* +* Copyright (c) 2017-2023 Ta4j Organization & respective +* authors (see AUTHORS) +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of +* this software and associated documentation files (the "Software"), to deal in +* the Software without restriction, including without limitation the rights to +* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +* the Software, and to permit persons to whom the Software is furnished to do so, +* subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ +package org.ta4j.core.num; + +public class DecimalNumFactory implements NumFactory { + @Override + public Num minusOne() { + return DecimalNum.MINUS_ONE; + } + + @Override + public Num zero() { + return DecimalNum.ZERO; + } + + @Override + public Num one() { + return DecimalNum.ONE; + } + + @Override + public Num two() { + return DecimalNum.TWO; + } + + @Override + public Num three() { + return DecimalNum.THREE; + } + + @Override + public Num hundred() { + return DecimalNum.HUNDRED; + } + + @Override + public Num thousand() { + return DecimalNum.THOUSAND; + } + + @Override + public Num numOf(final Number number) { + return DecimalNum.valueOf(number); + } + + @Override + public Num numOf(final String number) { + return DecimalNum.valueOf(number); + } +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java index 0413ea4a3..ceb4aff8e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java @@ -37,9 +37,13 @@ public class DoubleNum implements Num { private static final long serialVersionUID = 1L; + public static final DoubleNum MINUS_ONE = DoubleNum.valueOf(-1); public static final DoubleNum ZERO = DoubleNum.valueOf(0); - private static final DoubleNum ONE = DoubleNum.valueOf(1); - private static final DoubleNum HUNDRED = DoubleNum.valueOf(100); + public static final DoubleNum ONE = DoubleNum.valueOf(1); + public static final DoubleNum TWO = DoubleNum.valueOf(2); + public static final DoubleNum THREE = DoubleNum.valueOf(3); + public static final DoubleNum HUNDRED = DoubleNum.valueOf(100); + public static final DoubleNum THOUSAND = DoubleNum.valueOf(1000); private final static double EPS = 0.00001; // precision private final double delegate; @@ -61,7 +65,7 @@ public static DoubleNum valueOf(String val) { /** * Returns a {@code Num} version of the given {@code Number}. * - * @param val the number + * @param i the number * @return the {@code Num} */ public static DoubleNum valueOf(Number i) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java new file mode 100644 index 000000000..4b60b51f6 --- /dev/null +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java @@ -0,0 +1,71 @@ +/** +* The MIT License (MIT) +* +* Copyright (c) 2017-2023 Ta4j Organization & respective +* authors (see AUTHORS) +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of +* this software and associated documentation files (the "Software"), to deal in +* the Software without restriction, including without limitation the rights to +* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +* the Software, and to permit persons to whom the Software is furnished to do so, +* subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ +package org.ta4j.core.num; + +public class DoubleNumFactory implements NumFactory { + @Override + public Num minusOne() { + return DoubleNum.MINUS_ONE; + } + + @Override + public Num zero() { + return DoubleNum.ZERO; + } + + @Override + public Num one() { + return DoubleNum.ONE; + } + + @Override + public Num two() { + return DoubleNum.TWO; + } + + @Override + public Num three() { + return DoubleNum.THREE; + } + + @Override + public Num hundred() { + return DoubleNum.HUNDRED; + } + + @Override + public Num thousand() { + return DoubleNum.THOUSAND; + } + + @Override + public Num numOf(final Number number) { + return DoubleNum.valueOf(number); + } + + @Override + public Num numOf(final String number) { + return DoubleNum.valueOf(number); + } +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/Num.java b/ta4j-core/src/main/java/org/ta4j/core/num/Num.java index b8ef30d68..6c91b131f 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/Num.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/Num.java @@ -40,6 +40,7 @@ */ public interface Num extends Comparable, Serializable { + // TODO remove constants /** * @return the Num of 0 */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java new file mode 100644 index 000000000..060dee4b8 --- /dev/null +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java @@ -0,0 +1,80 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package org.ta4j.core.num; + +public interface NumFactory { + + /** + * @return the Num of -1 + */ + Num minusOne(); + + /** + * @return the Num of 0 + */ + Num zero(); + + /** + * @return the Num of 1 + */ + Num one(); + + /** + * @return the Num of 2 + */ + Num two(); + + /** + * @return the Num of 3 + */ + Num three(); + + /** + * @return the Num of 100 + */ + Num hundred(); + + /** + * @return the Num of 100 + */ + Num thousand(); + + /** + * Transforms a {@link Number} into the {@link Num implementation} used by this + * bar series + * + * @param number a {@link Number} implementing object. + * @return the corresponding value as a Num implementing object + */ + Num numOf(Number number); + + /** + * Transforms a {@link Number} into the {@link Num implementation} used by this + * bar series + * + * @param number as string + * @return the corresponding value as a Num implementing object + */ + Num numOf(String number); +} diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedDownIndicatorRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedDownIndicatorRule.java index 94f25a65d..ba4badc4d 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedDownIndicatorRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedDownIndicatorRule.java @@ -45,7 +45,7 @@ public class CrossedDownIndicatorRule extends AbstractRule { * @param threshold a threshold */ public CrossedDownIndicatorRule(Indicator indicator, Number threshold) { - this(indicator, indicator.numOf(threshold)); + this(indicator, indicator.getBarSeries().numFactory().numOf(threshold)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedUpIndicatorRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedUpIndicatorRule.java index 6e7f16bef..1e1a19d0a 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedUpIndicatorRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/CrossedUpIndicatorRule.java @@ -45,7 +45,7 @@ public class CrossedUpIndicatorRule extends AbstractRule { * @param threshold the threshold */ public CrossedUpIndicatorRule(Indicator indicator, Number threshold) { - this(indicator, indicator.numOf(threshold)); + this(indicator, indicator.getBarSeries().numFactory().numOf(threshold)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/InPipeRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/InPipeRule.java index 791767a9a..6a45ba075 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/InPipeRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/InPipeRule.java @@ -51,7 +51,7 @@ public class InPipeRule extends AbstractRule { * @param lower the lower threshold */ public InPipeRule(Indicator ref, Number upper, Number lower) { - this(ref, ref.numOf(upper), ref.numOf(lower)); + this(ref, ref.getBarSeries().numFactory().numOf(upper), ref.getBarSeries().numFactory().numOf(lower)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/IsEqualRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/IsEqualRule.java index eff9306d7..b7fdd87fb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/IsEqualRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/IsEqualRule.java @@ -47,7 +47,7 @@ public class IsEqualRule extends AbstractRule { * @param value the value to check */ public IsEqualRule(Indicator indicator, Number value) { - this(indicator, indicator.numOf(value)); + this(indicator, indicator.getBarSeries().numFactory().numOf(value)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/OverIndicatorRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/OverIndicatorRule.java index 0dab77a77..0c1554224 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/OverIndicatorRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/OverIndicatorRule.java @@ -50,7 +50,7 @@ public class OverIndicatorRule extends AbstractRule { * @param threshold the threshold */ public OverIndicatorRule(Indicator indicator, Number threshold) { - this(indicator, indicator.numOf(threshold)); + this(indicator, indicator.getBarSeries().numFactory().numOf(threshold)); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/StopGainRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/StopGainRule.java index ddf36230d..96e22b690 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/StopGainRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/StopGainRule.java @@ -52,7 +52,7 @@ public class StopGainRule extends AbstractRule { * @param gainPercentage the gain percentage */ public StopGainRule(ClosePriceIndicator closePrice, Number gainPercentage) { - this(closePrice, closePrice.numOf(gainPercentage)); + this(closePrice, closePrice.getBarSeries().numFactory().numOf(gainPercentage)); } /** @@ -64,7 +64,7 @@ public StopGainRule(ClosePriceIndicator closePrice, Number gainPercentage) { public StopGainRule(ClosePriceIndicator closePrice, Num gainPercentage) { this.closePrice = closePrice; this.gainPercentage = gainPercentage; - HUNDRED = closePrice.numOf(100); + HUNDRED = closePrice.getBarSeries().numFactory().hundred(); } /** This rule uses the {@code tradingRecord}. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/StopLossRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/StopLossRule.java index 91d513e0f..927c79230 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/StopLossRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/StopLossRule.java @@ -36,9 +36,6 @@ */ public class StopLossRule extends AbstractRule { - /** The constant value for 100. */ - private final Num HUNDRED; - /** The close price indicator. */ private final ClosePriceIndicator closePrice; @@ -52,7 +49,7 @@ public class StopLossRule extends AbstractRule { * @param lossPercentage the loss percentage */ public StopLossRule(ClosePriceIndicator closePrice, Number lossPercentage) { - this(closePrice, closePrice.numOf(lossPercentage)); + this(closePrice, closePrice.getBarSeries().numFactory().numOf(lossPercentage)); } /** @@ -64,7 +61,6 @@ public StopLossRule(ClosePriceIndicator closePrice, Number lossPercentage) { public StopLossRule(ClosePriceIndicator closePrice, Num lossPercentage) { this.closePrice = closePrice; this.lossPercentage = lossPercentage; - this.HUNDRED = closePrice.numOf(100); } /** This rule uses the {@code tradingRecord}. */ @@ -91,13 +87,15 @@ public boolean isSatisfied(int index, TradingRecord tradingRecord) { } private boolean isBuyStopSatisfied(Num entryPrice, Num currentPrice) { - Num lossRatioThreshold = HUNDRED.minus(lossPercentage).dividedBy(HUNDRED); + final var hundred = closePrice.getBarSeries().numFactory().hundred(); + Num lossRatioThreshold = hundred.minus(lossPercentage).dividedBy(hundred); Num threshold = entryPrice.multipliedBy(lossRatioThreshold); return currentPrice.isLessThanOrEqual(threshold); } private boolean isSellStopSatisfied(Num entryPrice, Num currentPrice) { - Num lossRatioThreshold = HUNDRED.plus(lossPercentage).dividedBy(HUNDRED); + final var hundred = closePrice.getBarSeries().numFactory().hundred(); + Num lossRatioThreshold = hundred.plus(lossPercentage).dividedBy(hundred); Num threshold = entryPrice.multipliedBy(lossRatioThreshold); return currentPrice.isGreaterThanOrEqual(threshold); } diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/UnderIndicatorRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/UnderIndicatorRule.java index 7660fe443..86f5033fb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/UnderIndicatorRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/UnderIndicatorRule.java @@ -50,7 +50,8 @@ public class UnderIndicatorRule extends AbstractRule { * @param threshold the threshold */ public UnderIndicatorRule(Indicator indicator, Number threshold) { - this(indicator, new ConstantIndicator<>(indicator.getBarSeries(), indicator.numOf(threshold))); + this(indicator, new ConstantIndicator<>(indicator.getBarSeries(), + indicator.getBarSeries().numFactory().numOf(threshold))); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/utils/BarSeriesUtils.java b/ta4j-core/src/main/java/org/ta4j/core/utils/BarSeriesUtils.java index 4da7a9fa9..a619a53b5 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/utils/BarSeriesUtils.java +++ b/ta4j-core/src/main/java/org/ta4j/core/utils/BarSeriesUtils.java @@ -29,17 +29,16 @@ import java.util.Collections; import java.util.Comparator; import java.util.List; -import java.util.function.Function; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.BaseBarConvertibleBuilder; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.aggregator.BarAggregator; import org.ta4j.core.aggregator.BarSeriesAggregator; import org.ta4j.core.aggregator.BaseBarSeriesAggregator; import org.ta4j.core.aggregator.DurationBarAggregator; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Common utilities and helper methods for {@link BarSeries}. @@ -145,21 +144,22 @@ public static List findMissingBars(BarSeries barSeries, boolean f * by conversionFunction. The returned barSeries inherits {@code beginIndex}, * {@code endIndex} and {@code maximumBarCount} from the provided barSeries. * - * @param barSeries the BarSeries - * @param num any instance of Num to determine its Num function; with - * this, we can convert a {@link Number} to a {@link Num Num - * implementation} + * @param barSeries the BarSeries + * @param numFactory produces numbers used in converted barsŚeries; with this, + * we can convert a {@link Number} to a {@link Num Num + * implementation} * @return new cloned BarSeries with bars converted by the Num function of num */ - public static BarSeries convertBarSeries(BarSeries barSeries, Num num) { + public static BarSeries convertBarSeries(BarSeries barSeries, NumFactory numFactory) { List bars = barSeries.getBarData(); if (bars == null || bars.isEmpty()) return barSeries; - List convertedBars = new ArrayList<>(); + var convertedBarSeries = new BaseBarSeriesBuilder().withName(barSeries.getName()) + .withNumFactory(numFactory) + .build(); for (int i = barSeries.getBeginIndex(); i <= barSeries.getEndIndex(); i++) { Bar bar = bars.get(i); - Function conversionFunction = num.function(); - Bar convertedBar = new BaseBarConvertibleBuilder<>(conversionFunction::apply) + convertedBarSeries.barBuilder() .timePeriod(bar.getTimePeriod()) .endTime(bar.getEndTime()) .openPrice(bar.getOpenPrice().getDelegate()) @@ -169,10 +169,9 @@ public static BarSeries convertBarSeries(BarSeries barSeries, Num num) { .volume(bar.getVolume().getDelegate()) .amount(bar.getAmount().getDelegate()) .trades(bar.getTrades()) - .build(); - convertedBars.add(convertedBar); + .add(); } - BarSeries convertedBarSeries = new BaseBarSeries(barSeries.getName(), convertedBars, num); + if (barSeries.getMaximumBarCount() > 0) { convertedBarSeries.setMaximumBarCount(barSeries.getMaximumBarCount()); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java index aba21377d..8b4de556b 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java @@ -36,9 +36,6 @@ import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; -import java.util.LinkedList; -import java.util.List; -import java.util.function.Function; import java.util.stream.IntStream; import org.junit.Assert; @@ -49,10 +46,13 @@ import org.ta4j.core.indicators.helpers.HighPriceIndicator; import org.ta4j.core.indicators.helpers.LowPriceIndicator; import org.ta4j.core.indicators.helpers.PreviousValueIndicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarBuilderFactory; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.FixedRule; public class BarSeriesTest extends AbstractIndicatorTest { @@ -63,68 +63,98 @@ public class BarSeriesTest extends AbstractIndicatorTest { private BarSeries emptySeries; - private List bars; - private String defaultName; - public BarSeriesTest(Function numFunction) { - super(numFunction); + public BarSeriesTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - bars = new LinkedList<>(); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 13, 0, 0, 0, 0, ZoneId.systemDefault()), 1d, numFunction)); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 14, 0, 0, 0, 0, ZoneId.systemDefault()), 2d, numFunction)); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 15, 0, 0, 0, 0, ZoneId.systemDefault()), 3d, numFunction)); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 20, 0, 0, 0, 0, ZoneId.systemDefault()), 4d, numFunction)); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 25, 0, 0, 0, 0, ZoneId.systemDefault()), 5d, numFunction)); - bars.add(new MockBar(ZonedDateTime.of(2014, 6, 30, 0, 0, 0, 0, ZoneId.systemDefault()), 6d, numFunction)); - defaultName = "Series Name"; - defaultSeries = new BaseBarSeriesBuilder().withNumTypeOf(numFunction) + defaultSeries = new BaseBarSeriesBuilder().withNumFactory(numFactory) .withName(defaultName) - .withBars(bars) + .withBarBuilderFactory(new MockBarBuilderFactory()) .build(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 13, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(1d) + .add(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 14, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(2d) + .add(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 15, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(3d) + .add(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 20, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(4d) + .add(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 25, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(5d) + .add(); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.of(2014, 6, 30, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(6d) + .add(); + subSeries = defaultSeries.getSubSeries(2, 5); - emptySeries = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + emptySeries = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); Strategy strategy = new BaseStrategy(new FixedRule(0, 2, 3, 6), new FixedRule(1, 4, 7, 8)); strategy.setUnstableBars(2); // Strategy would need a real test class } - @Test - public void createWithUnmodifiableCollectionTest() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withBars(List.copyOf(bars)).build(); - series.addBar(new MockBar(ZonedDateTime.of(2014, 7, 1, 0, 0, 0, 0, ZoneId.systemDefault()), 7d, numFunction)); - assertEquals(7, series.getBarCount()); - assertEquals(0, series.getBeginIndex()); - assertEquals(6, series.getEndIndex()); - assertNumEquals(1d, series.getFirstBar().getClosePrice()); - assertNumEquals(7d, series.getLastBar().getClosePrice()); - - } - /** * Tests if the addBar(bar, boolean) function works correct. */ @Test public void replaceBarTest() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()), 1d, numFunction), true); + var series = new BaseBarSeriesBuilder().withNumFactory(numFactory) + .withBarBuilderFactory(new MockBarBuilderFactory()) + .build(); + series.addBar(series.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now(ZoneId.systemDefault())) + .closePrice(1d) + .build(), true); assertEquals(1, series.getBarCount()); - assertNumEquals(series.getLastBar().getClosePrice(), series.one()); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(1), 2d, numFunction), false); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(2), 3d, numFunction), false); + assertNumEquals(series.getLastBar().getClosePrice(), series.numFactory().one()); + + series.addBar(series.barBuilder() + .endTime(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(1)) + .closePrice(2d) + .build(), false); + series.addBar(series.barBuilder() + .endTime(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(2)) + .closePrice(3d) + .build(), false); assertEquals(3, series.getBarCount()); - assertNumEquals(series.getLastBar().getClosePrice(), series.numOf(3)); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(3), 4d, numFunction), true); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(4), 5d, numFunction), true); + + assertNumEquals(series.getLastBar().getClosePrice(), series.numFactory().numOf(3)); + series.addBar(series.barBuilder() + .endTime(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(3)) + .closePrice(4d) + .build(), true); + series.addBar(series.barBuilder() + .endTime(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(4)) + .closePrice(5d) + .build(), true); assertEquals(3, series.getBarCount()); - assertNumEquals(series.getLastBar().getClosePrice(), series.numOf(5)); + + assertNumEquals(series.getLastBar().getClosePrice(), series.numFactory().numOf(5)); } @Test @@ -132,8 +162,8 @@ public void getEndGetBeginGetBarCountIsEmptyTest() { // Default series assertEquals(0, defaultSeries.getBeginIndex()); - assertEquals(bars.size() - 1, defaultSeries.getEndIndex()); - assertEquals(bars.size(), defaultSeries.getBarCount()); + assertEquals(defaultSeries.getBarData().size() - 1, defaultSeries.getEndIndex()); + assertEquals(defaultSeries.getBarData().size(), defaultSeries.getBarCount()); assertFalse(defaultSeries.isEmpty()); // Constrained series assertEquals(0, subSeries.getBeginIndex()); @@ -149,10 +179,8 @@ public void getEndGetBeginGetBarCountIsEmptyTest() { @Test public void getBarDataTest() { - // Default series - assertEquals(bars, defaultSeries.getBarData()); // Constrained series - assertNotEquals(bars, subSeries.getBarData()); + assertNotEquals(defaultSeries.getBarData(), subSeries.getBarData()); // Empty series assertEquals(0, emptySeries.getBarData().size()); } @@ -161,15 +189,20 @@ public void getBarDataTest() { public void getSeriesPeriodDescriptionTest() { // Default series assertTrue(defaultSeries.getSeriesPeriodDescription() - .endsWith(bars.get(defaultSeries.getEndIndex()).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); + .endsWith(defaultSeries.getBarData() + .get(defaultSeries.getEndIndex()) + .getEndTime() + .format(DateTimeFormatter.ISO_DATE_TIME))); assertTrue(defaultSeries.getSeriesPeriodDescription() - .startsWith( - bars.get(defaultSeries.getBeginIndex()).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); + .startsWith(defaultSeries.getBarData() + .get(defaultSeries.getBeginIndex()) + .getEndTime() + .format(DateTimeFormatter.ISO_DATE_TIME))); // Constrained series assertTrue(subSeries.getSeriesPeriodDescription() - .endsWith(bars.get(4).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); + .endsWith(defaultSeries.getBarData().get(4).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); assertTrue(subSeries.getSeriesPeriodDescription() - .startsWith(bars.get(2).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); + .startsWith(defaultSeries.getBarData().get(2).getEndTime().format(DateTimeFormatter.ISO_DATE_TIME))); // Empty series assertEquals("", emptySeries.getSeriesPeriodDescription()); } @@ -196,7 +229,6 @@ public void getBarWithRemovedIndexOnMovingSeriesShouldReturnFirstRemainingBarTes @Test public void modificationsOnOriginalListShouldNotAffectBarSeries() { defaultSeries.setMaximumBarCount(2); - bars.clear(); assertEquals(2, defaultSeries.getBarCount()); assertNumEquals(5, defaultSeries.getBar(1).getClosePrice()); } @@ -263,8 +295,8 @@ public void negativeMaximumBarCountShouldThrowExceptionTest() { public void setMaximumBarCountTest() { // Before assertEquals(0, defaultSeries.getBeginIndex()); - assertEquals(bars.size() - 1, defaultSeries.getEndIndex()); - assertEquals(bars.size(), defaultSeries.getBarCount()); + assertEquals(defaultSeries.getBarData().size() - 1, defaultSeries.getEndIndex()); + assertEquals(defaultSeries.getBarData().size(), defaultSeries.getBarCount()); defaultSeries.setMaximumBarCount(3); @@ -281,15 +313,26 @@ public void addNullBarShouldThrowExceptionTest() { @Test(expected = IllegalArgumentException.class) public void addBarWithEndTimePriorToSeriesEndTimeShouldThrowExceptionTest() { - defaultSeries.addBar( - new MockBar(ZonedDateTime.of(2000, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault()), 99d, numFunction)); + defaultSeries.addBar(defaultSeries.barBuilder() + .endTime(ZonedDateTime.of(2000, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(99d) + .build()); } @Test public void addBarTest() { - defaultSeries = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); - Bar bar1 = new MockBar(ZonedDateTime.of(2014, 6, 13, 0, 0, 0, 0, ZoneId.systemDefault()), 1d, numFunction); - Bar bar2 = new MockBar(ZonedDateTime.of(2014, 6, 14, 0, 0, 0, 0, ZoneId.systemDefault()), 2d, numFunction); + defaultSeries = new BaseBarSeriesBuilder().withNumFactory(numFactory) + .withBarBuilderFactory(new MockBarBuilderFactory()) + .build(); + Bar bar1 = defaultSeries.barBuilder() + .endTime(ZonedDateTime.of(2014, 6, 13, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(1d) + .build(); + + Bar bar2 = defaultSeries.barBuilder() + .endTime(ZonedDateTime.of(2014, 6, 14, 0, 0, 0, 0, ZoneId.systemDefault())) + .closePrice(2d) + .build(); assertEquals(0, defaultSeries.getBarCount()); assertEquals(-1, defaultSeries.getBeginIndex()); @@ -308,10 +351,10 @@ public void addBarTest() { @Test public void addPriceTest() { - ClosePriceIndicator cp = new ClosePriceIndicator(defaultSeries); - HighPriceIndicator mxPrice = new HighPriceIndicator(defaultSeries); - LowPriceIndicator mnPrice = new LowPriceIndicator(defaultSeries); - PreviousValueIndicator prevValue = new PreviousValueIndicator(cp, 1); + var cp = new ClosePriceIndicator(defaultSeries); + var mxPrice = new HighPriceIndicator(defaultSeries); + var mnPrice = new LowPriceIndicator(defaultSeries); + var prevValue = new PreviousValueIndicator(cp, 1); Num adding1 = numOf(100); Num prevClose = defaultSeries.getBar(defaultSeries.getEndIndex() - 1).getClosePrice(); @@ -339,38 +382,48 @@ public void addPriceTest() { */ @Test public void addTradeTest() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); - series.addBar(new MockBar(ZonedDateTime.now(ZoneId.systemDefault()), 1d, numFunction)); + var series = new BaseBarSeriesBuilder().withNumFactory(numFactory) + .withBarBuilderFactory(new MockBarBuilderFactory()) + .build(); + series.barBuilder().closePrice(1d).volume(0).amount(0).add(); series.addTrade(200, 11.5); - assertNumEquals(series.numOf(200), series.getLastBar().getVolume()); - assertNumEquals(series.numOf(11.5), series.getLastBar().getClosePrice()); + assertNumEquals(series.numFactory().numOf(200), series.getLastBar().getVolume()); + assertNumEquals(series.numFactory().numOf(11.5), series.getLastBar().getClosePrice()); series.addTrade(BigDecimal.valueOf(200), BigDecimal.valueOf(100)); - assertNumEquals(series.numOf(400), series.getLastBar().getVolume()); - assertNumEquals(series.numOf(100), series.getLastBar().getClosePrice()); + assertNumEquals(series.numFactory().numOf(400), series.getLastBar().getVolume()); + assertNumEquals(series.numFactory().numOf(100), series.getLastBar().getClosePrice()); } @Test(expected = IllegalArgumentException.class) public void wrongBarTypeDoubleTest() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(DoubleNum.class).build(); + var series = new BaseBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).build(); series.addBar(new BaseBar(Duration.ofDays(1), ZonedDateTime.now(), 1, 1, 1, 1, 1, 1, 1, DecimalNum::valueOf)); } @Test(expected = IllegalArgumentException.class) public void wrongBarTypeBigDecimalTest() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(DecimalNum::valueOf).build(); + var series = new BaseBarSeriesBuilder().withNumFactory(new DecimalNumFactory()).build(); series.addBar(new BaseBar(Duration.ofDays(1), ZonedDateTime.now(), 1, 1, 1, 1, 1, 1, 1, DoubleNum::valueOf)); } @Test public void subSeriesOfMaxBarCountSeriesTest() { - final BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction) + final BarSeries series = new BaseBarSeriesBuilder().withNumFactory(numFactory) .withName("Series with maxBar count") .withMaxBarCount(20) .build(); final int timespan = 5; IntStream.range(0, 100).forEach(i -> { - series.addBar(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(i), 5, 7, 1, 5, i); + series.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now(ZoneId.systemDefault()).plusMinutes(i)) + .openPrice(5) + .highPrice(7) + .lowPrice(1) + .closePrice(5) + .volume(i) + .add(); int startIndex = Math.max(series.getBeginIndex(), series.getEndIndex() - timespan + 1); int endIndex = i + 1; final BarSeries subSeries = series.getSubSeries(startIndex, endIndex); diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarTest.java index c5a7b5a16..5755db069 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarTest.java @@ -30,12 +30,12 @@ import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BarTest extends AbstractIndicatorTest { @@ -45,15 +45,19 @@ public class BarTest extends AbstractIndicatorTest { private ZonedDateTime endTime; - public BarTest(Function numFunction) { - super(null, numFunction); + public BarTest(NumFactory numFactory) { + super(null, numFactory); } @Before public void setUp() { beginTime = ZonedDateTime.of(2014, 6, 25, 0, 0, 0, 0, ZoneId.systemDefault()); endTime = ZonedDateTime.of(2014, 6, 25, 1, 0, 0, 0, ZoneId.systemDefault()); - bar = new BaseBar(Duration.ofHours(1), endTime, numFunction); + bar = new BaseBarConvertibleBuilder(numFactory).timePeriod(Duration.ofHours(1)) + .endTime(endTime) + .volume(0) + .amount(0) + .build(); } @Test @@ -96,16 +100,16 @@ public void inPeriod() { @Test public void equals() { - Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFunction); - Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFunction); + Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFactory); + Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFactory); assertEquals(bar1, bar2); } @Test public void hashCode2() { - Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFunction); - Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFunction); + Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFactory); + Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFactory); assertEquals(bar1.hashCode(), bar2.hashCode()); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/BaseBarBuilderTest.java b/ta4j-core/src/test/java/org/ta4j/core/BaseBarBuilderTest.java index 7cda8f735..470c6c9a1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BaseBarBuilderTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BaseBarBuilderTest.java @@ -28,16 +28,16 @@ import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BaseBarBuilderTest extends AbstractIndicatorTest { - public BaseBarBuilderTest(Function numFunction) { - super(numFunction); + public BaseBarBuilderTest(NumFactory numFactory) { + super(numFactory); } @Test @@ -68,4 +68,4 @@ public void testBuildBar() { assertEquals(numOf(40), bar.getVolume()); assertEquals(numOf(4020), bar.getAmount()); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/BaseBarConvertibleBuilderTest.java b/ta4j-core/src/test/java/org/ta4j/core/BaseBarConvertibleBuilderTest.java index 6d388e346..df82f20fd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BaseBarConvertibleBuilderTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BaseBarConvertibleBuilderTest.java @@ -30,31 +30,31 @@ import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; @RunWith(Parameterized.class) public class BaseBarConvertibleBuilderTest extends AbstractIndicatorTest { - public BaseBarConvertibleBuilderTest(Function numFunction) { - super(numFunction); + public BaseBarConvertibleBuilderTest(NumFactory numFactory) { + super(numFactory); } @Test public void testBuildBigDecimal() { - new BaseBarConvertibleBuilder(DecimalNum::valueOf); final ZonedDateTime beginTime = ZonedDateTime.of(2014, 6, 25, 0, 0, 0, 0, ZoneId.systemDefault()); final ZonedDateTime endTime = ZonedDateTime.of(2014, 6, 25, 1, 0, 0, 0, ZoneId.systemDefault()); final Duration duration = Duration.between(beginTime, endTime); - final BaseBar bar = new BaseBarConvertibleBuilder(this::numOf).timePeriod(duration) + final var series = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); + final var bar = series.barBuilder() + .timePeriod(duration) .endTime(endTime) .openPrice(BigDecimal.valueOf(101.0)) .highPrice(BigDecimal.valueOf(103)) diff --git a/ta4j-core/src/test/java/org/ta4j/core/IndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/IndicatorTest.java index 54e837422..e3dad8f7d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/IndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/IndicatorTest.java @@ -29,7 +29,6 @@ import java.util.Arrays; import java.util.List; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -37,9 +36,10 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.mocks.MockIndicator; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class IndicatorTest extends AbstractIndicatorTest, Num> { @@ -48,19 +48,19 @@ public class IndicatorTest extends AbstractIndicatorTest, Num> { 24.35, 23.75, 24.09 }; BarSeries data; - public IndicatorTest(Function numFunction) { - super(numFunction); + public IndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, typicalPrices); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(typicalPrices).build(); } @Test public void toDouble() { List expectedValues = Arrays.stream(typicalPrices) - .mapToObj(numFunction::apply) + .mapToObj(numFactory::numOf) .collect(Collectors.toList()); MockIndicator closePriceMockIndicator = new MockIndicator(data, expectedValues); @@ -76,7 +76,7 @@ public void toDouble() { @Test public void shouldProvideStream() { List expectedValues = Arrays.stream(typicalPrices) - .mapToObj(numFunction::apply) + .mapToObj(numFactory::numOf) .collect(Collectors.toList()); MockIndicator closePriceMockIndicator = new MockIndicator(data, expectedValues); diff --git a/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java b/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java index c281e86b4..1c8fd6884 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java @@ -37,8 +37,9 @@ import org.ta4j.core.analysis.cost.LinearBorrowingCostModel; import org.ta4j.core.analysis.cost.LinearTransactionCostModel; import org.ta4j.core.analysis.cost.ZeroCostModel; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; public class PositionTest { @@ -243,14 +244,14 @@ public void testGetGrossReturnForShortPositions() { @Test public void testGetGrossReturnForLongPositionsUsingBarCloseOnNaN() { - MockBarSeries series = new MockBarSeries(DoubleNum::valueOf, 100, 105); + var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).withData(100, 105).build(); Position position = new Position(new Trade(0, TradeType.BUY, NaN, NaN), new Trade(1, TradeType.SELL, NaN, NaN)); assertNumEquals(DoubleNum.valueOf(1.05), position.getGrossReturn(series)); } @Test public void testGetGrossReturnForShortPositionsUsingBarCloseOnNaN() { - MockBarSeries series = new MockBarSeries(DoubleNum::valueOf, 100, 95); + var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).withData(100, 95).build(); Position position = new Position(new Trade(0, TradeType.SELL, NaN, NaN), new Trade(1, TradeType.BUY, NaN, NaN)); assertNumEquals(DoubleNum.valueOf(1.05), position.getGrossReturn(series)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java index b93e195d4..fe5e4ba26 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java @@ -25,24 +25,20 @@ import static junit.framework.TestCase.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import static org.ta4j.core.TestUtils.assertNumNotEquals; +import java.time.Duration; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Test; -import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; +import org.ta4j.core.num.DoubleNumFactory; -public class SeriesBuilderTest extends AbstractIndicatorTest { +public class SeriesBuilderTest { - public SeriesBuilderTest(Function numFunction) { - super(numFunction); - } - - private final BaseBarSeriesBuilder seriesBuilder = new BaseBarSeriesBuilder().withNumTypeOf(numFunction); + private final BaseBarSeriesBuilder seriesBuilder = new BaseBarSeriesBuilder() + .withNumFactory(new DecimalNumFactory()); @Test public void testBuilder() { @@ -50,19 +46,51 @@ public void testBuilder() { BarSeries defaultSeriesName = seriesBuilder.withName("default").build(); // build a new empty bar series using // BigDecimal as delegate BarSeries doubleSeries = seriesBuilder.withMaxBarCount(100) - .withNumTypeOf(DoubleNum.class) + .withNumFactory(new DoubleNumFactory()) .withName("useDoubleNum") .build(); BarSeries precisionSeries = seriesBuilder.withMaxBarCount(100) - .withNumTypeOf(DecimalNum.class) + .withNumFactory(new DecimalNumFactory()) .withName("usePrecisionNum") .build(); for (int i = 1000; i >= 0; i--) { - defaultSeries.addBar(ZonedDateTime.now().minusSeconds(i), i, i, i, i, i); - defaultSeriesName.addBar(ZonedDateTime.now().minusSeconds(i), i, i, i, i, i); - doubleSeries.addBar(ZonedDateTime.now().minusSeconds(i), i, i, i, i, i); - precisionSeries.addBar(ZonedDateTime.now().minusSeconds(i), i, i, i, i, i); + defaultSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now().minusSeconds(i)) + .openPrice(i) + .closePrice(i) + .highPrice(i) + .lowPrice(i) + .volume(i) + .add(); + defaultSeriesName.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now().minusSeconds(i)) + .openPrice(i) + .closePrice(i) + .highPrice(i) + .lowPrice(i) + .volume(i) + .add(); + doubleSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now().minusSeconds(i)) + .openPrice(i) + .closePrice(i) + .highPrice(i) + .lowPrice(i) + .volume(i) + .add(); + precisionSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now().minusSeconds(i)) + .openPrice(i) + .closePrice(i) + .highPrice(i) + .lowPrice(i) + .volume(i) + .add(); } assertNumEquals(0, defaultSeries.getBar(1000).getClosePrice()); @@ -74,16 +102,13 @@ public void testBuilder() { @Test public void testNumFunctions() { - BarSeries series = seriesBuilder.withNumTypeOf(DoubleNum.class).build(); - assertNumEquals(series.numOf(12), DoubleNum.valueOf(12)); - - BarSeries seriesB = seriesBuilder.withNumTypeOf(DecimalNum.class).build(); - assertNumEquals(seriesB.numOf(12), DecimalNum.valueOf(12)); + BarSeries series = seriesBuilder.withNumFactory(new DoubleNumFactory()).build(); + assertNumEquals(series.numFactory().numOf(12), DoubleNum.valueOf(12)); } @Test public void testWrongNumType() { - BarSeries series = seriesBuilder.withNumTypeOf(DecimalNum.class).build(); - assertNumNotEquals(series.numOf(12), DoubleNum.valueOf(12)); + BarSeries series = seriesBuilder.withNumFactory(new DecimalNumFactory()).build(); + assertNumEquals(series.numFactory().numOf(12), DecimalNum.valueOf(12)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/TestUtilsTest.java b/ta4j-core/src/test/java/org/ta4j/core/TestUtilsTest.java index 1afe9181d..62af4e532 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/TestUtilsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/TestUtilsTest.java @@ -32,12 +32,12 @@ import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TestUtilsTest extends AbstractIndicatorTest { @@ -58,8 +58,8 @@ public class TestUtilsTest extends AbstractIndicatorTest { private static Indicator indicator; private static Indicator diffIndicator; - public TestUtilsTest(Function numFunction) { - super(numFunction); + public TestUtilsTest(NumFactory numFactory) { + super(numFactory); numStringDouble = numOf(bigDecimalDouble); diffNumStringDouble = numOf(diffBigDecimalDouble); numInt = numOf(aInt); @@ -73,15 +73,23 @@ public TestUtilsTest(Function numFunction) { } private BarSeries randomSeries() { - BaseBarSeriesBuilder builder = new BaseBarSeriesBuilder(); - BarSeries series = builder.withNumTypeOf(numFunction).build(); + BarSeries series = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); ZonedDateTime time = ZonedDateTime.of(1970, 1, 1, 1, 1, 1, 1, ZoneId.systemDefault()); double random; for (int i = 0; i < 1000; i++) { random = Math.random(); time = time.plusDays(i); - series.addBar(new BaseBar(Duration.ofDays(1), time, random, random, random, random, random, random, 0, - numFunction)); + series.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(time) + .openPrice(random) + .closePrice(random) + .highPrice(random) + .lowPrice(random) + .amount(random) + .volume(random) + .trades(0) + .add(); } return series; } diff --git a/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java b/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java index e59d06cb1..39939caa0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java @@ -33,10 +33,10 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.Trade.TradeType; -import org.ta4j.core.analysis.cost.CostModel; import org.ta4j.core.analysis.cost.LinearTransactionCostModel; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; public class TradeTest { @@ -72,8 +72,8 @@ public void overrideToString() { @Test public void initializeWithCostsTest() { - CostModel transactionCostModel = new LinearTransactionCostModel(0.05); - Trade trade = new Trade(0, TradeType.BUY, DoubleNum.valueOf(100), DoubleNum.valueOf(20), transactionCostModel); + var transactionCostModel = new LinearTransactionCostModel(0.05); + var trade = new Trade(0, TradeType.BUY, DoubleNum.valueOf(100), DoubleNum.valueOf(20), transactionCostModel); Num expectedCost = DoubleNum.valueOf(100); Num expectedValue = DoubleNum.valueOf(2000); Num expectedRawPrice = DoubleNum.valueOf(100); @@ -88,7 +88,9 @@ public void initializeWithCostsTest() { @Test public void testReturnBarSeriesCloseOnNaN() { - MockBarSeries series = new MockBarSeries(DoubleNum::valueOf, 100, 95, 100, 80, 85, 130); + var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()) + .withData(100, 95, 100, 80, 85, 130) + .build(); Trade trade = new Trade(1, TradeType.BUY, NaN); assertNumEquals(DoubleNum.valueOf(95), trade.getPricePerAsset(series)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/XlsTestsUtils.java b/ta4j-core/src/test/java/org/ta4j/core/XlsTestsUtils.java index 4ebab66fd..fdfd2c02a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/XlsTestsUtils.java +++ b/ta4j-core/src/test/java/org/ta4j/core/XlsTestsUtils.java @@ -35,7 +35,6 @@ import java.util.Date; import java.util.Iterator; import java.util.List; -import java.util.function.Function; import java.util.zip.DataFormatException; import org.apache.poi.hssf.usermodel.HSSFWorkbook; @@ -48,6 +47,7 @@ import org.ta4j.core.mocks.MockTradingRecord; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class XlsTestsUtils { @@ -110,16 +110,19 @@ private static void setParams(Sheet sheet, Num... params) throws DataFormatExcep /** * Gets the BarSeries from a file. * - * @param clazz class containing the file resources - * @param fileName file name of the file resource + * @param clazz class containing the file resources + * @param fileName file name of the file resource + * @param numFactory + * * @return BarSeries of the data + * * @throws IOException if getSheet throws IOException * @throws DataFormatException if getSeries throws DataFormatException */ - public static BarSeries getSeries(Class clazz, String fileName, Function numFunction) + public static BarSeries getSeries(Class clazz, String fileName, NumFactory numFactory) throws IOException, DataFormatException { Sheet sheet = getSheet(clazz, fileName); - return getSeries(sheet, numFunction); + return getSeries(sheet, numFactory); } /** @@ -127,13 +130,16 @@ public static BarSeries getSeries(Class clazz, String fileName, Function numFunction) throws DataFormatException { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + private static BarSeries getSeries(Sheet sheet, NumFactory numFactory) throws DataFormatException { + BarSeries series = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); FormulaEvaluator evaluator = sheet.getWorkbook().getCreationHelper().createFormulaEvaluator(); List rows = getData(sheet); int minInterval = Integer.MAX_VALUE; @@ -164,13 +170,16 @@ private static BarSeries getSeries(Sheet sheet, Function numFunctio Date endDate = DateUtil.getJavaDate(cellValues[0].getNumberValue()); ZonedDateTime endDateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(endDate.getTime()), ZoneId.systemDefault()); - series.addBar(duration, endDateTime, - // open, high, low, close, volume - numFunction.apply(new BigDecimal(cellValues[1].formatAsString())), - numFunction.apply(new BigDecimal(cellValues[2].formatAsString())), - numFunction.apply(new BigDecimal(cellValues[3].formatAsString())), - numFunction.apply(new BigDecimal(cellValues[4].formatAsString())), - numFunction.apply(new BigDecimal(cellValues[5].formatAsString())), numFunction.apply(0)); + series.addBar(series.barBuilder() + .timePeriod(duration) + .endTime(endDateTime) + .openPrice(new BigDecimal(cellValues[1].formatAsString())) + .highPrice(new BigDecimal(cellValues[2].formatAsString())) + .lowPrice(new BigDecimal(cellValues[3].formatAsString())) + .closePrice(new BigDecimal(cellValues[4].formatAsString())) + .volume(new BigDecimal(cellValues[5].formatAsString())) + .amount(0) + .build()); } return series; } @@ -185,12 +194,12 @@ private static BarSeries getSeries(Sheet sheet, Function numFunctio * @return List of values from the column * @throws DataFormatException if getValues returns DataFormatException */ - private static List getValues(Sheet sheet, int column, Function numFunction, Object... params) + private static List getValues(Sheet sheet, int column, NumFactory numFactory, Object... params) throws DataFormatException { Num[] NumParams = Arrays.stream(params) - .map(p -> numFunction.apply(new BigDecimal(p.toString()))) + .map(p -> numFactory.numOf(new BigDecimal(p.toString()))) .toArray(Num[]::new); - return getValues(sheet, column, numFunction, NumParams); + return getValues(sheet, column, numFactory, NumParams); } /** @@ -205,10 +214,10 @@ private static List getValues(Sheet sheet, int column, Function getValues(Sheet sheet, int column, Function numFunction, Num... params) + private static List getValues(Sheet sheet, int column, NumFactory numFactory, Num... params) throws DataFormatException { setParams(sheet, params); - return getValues(sheet, column, numFunction); + return getValues(sheet, column, numFactory); } /** @@ -220,8 +229,7 @@ private static List getValues(Sheet sheet, int column, Function of values from the column * @throws DataFormatException if getData throws DataFormatException */ - private static List getValues(Sheet sheet, int column, Function numFunction) - throws DataFormatException { + private static List getValues(Sheet sheet, int column, NumFactory numFactory) throws DataFormatException { List values = new ArrayList<>(); FormulaEvaluator evaluator = sheet.getWorkbook().getCreationHelper().createFormulaEvaluator(); // get all of the data from the data section of the sheet @@ -235,7 +243,7 @@ private static List getValues(Sheet sheet, int column, Function getData(Sheet sheet) throws DataFormatException { * @throws DataFormatException if getSeries or getValues throws * DataFormatException */ - public static Indicator getIndicator(Class clazz, String fileName, int column, - Function numFunction, Object... params) throws IOException, DataFormatException { + public static Indicator getIndicator(Class clazz, String fileName, int column, NumFactory numFactory, + Object... params) throws IOException, DataFormatException { Sheet sheet = getSheet(clazz, fileName); - return new MockIndicator(getSeries(sheet, numFunction), getValues(sheet, column, numFunction, params)); + return new MockIndicator(getSeries(sheet, numFactory), getValues(sheet, column, numFactory, params)); } /** @@ -311,10 +319,10 @@ public static Indicator getIndicator(Class clazz, String fileName, int c * @throws IOException if getSheet throws IOException * @throws DataFormatException if getValues throws DataFormatException */ - public static Num getFinalCriterionValue(Class clazz, String fileName, int column, - Function numFunction, Object... params) throws IOException, DataFormatException { + public static Num getFinalCriterionValue(Class clazz, String fileName, int column, NumFactory numFactory, + Object... params) throws IOException, DataFormatException { Sheet sheet = getSheet(clazz, fileName); - List values = getValues(sheet, column, numFunction, params); + List values = getValues(sheet, column, numFactory, params); return values.get(values.size() - 1); } @@ -328,10 +336,10 @@ public static Num getFinalCriterionValue(Class clazz, String fileName, int co * @throws IOException if getSheet throws IOException * @throws DataFormatException if getValues throws DataFormatException */ - public static TradingRecord getTradingRecord(Class clazz, String fileName, int column, - Function numFunction) throws IOException, DataFormatException { + public static TradingRecord getTradingRecord(Class clazz, String fileName, int column, NumFactory numFactory) + throws IOException, DataFormatException { Sheet sheet = getSheet(clazz, fileName); - return new MockTradingRecord(getValues(sheet, column, numFunction)); + return new MockTradingRecord(getValues(sheet, column, numFactory)); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/aggregator/BaseBarSeriesAggregatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/aggregator/BaseBarSeriesAggregatorTest.java index 3efb69cb1..dc06284ad 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/aggregator/BaseBarSeriesAggregatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/aggregator/BaseBarSeriesAggregatorTest.java @@ -31,38 +31,64 @@ import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BaseBarSeriesAggregatorTest extends AbstractIndicatorTest { private final BaseBarSeriesAggregator baseBarSeriesAggregator = new BaseBarSeriesAggregator( new BarAggregatorForTest()); - public BaseBarSeriesAggregatorTest(Function numFunction) { - super(numFunction); + public BaseBarSeriesAggregatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void testAggregateWithNewName() { final List bars = new LinkedList<>(); - final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 6d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 2d, 3d, 3d, 4d, 5d, 6d, 7, numFunction); - final Bar bar2 = new MockBar(time.plusDays(2), 3d, 4d, 4d, 5d, 6d, 7d, 7, numFunction); - bars.add(bar0); - bars.add(bar1); - bars.add(bar2); + final BarSeries barSeries = new MockBarSeriesBuilder().withName("name").build(); + final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); - final BarSeries barSeries = new BaseBarSeries("name", bars); + var bar0 = barSeries.barBuilder() + .endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .volume(5d) + .amount(6d) + .trades(7) + .build(); + var bar1 = barSeries.barBuilder() + .endTime(time.plusDays(1)) + .openPrice(2d) + .closePrice(3d) + .highPrice(3d) + .lowPrice(4d) + .volume(5d) + .amount(6d) + .trades(7) + .build(); + var bar2 = barSeries.barBuilder() + .endTime(time.plusDays(2)) + .openPrice(3d) + .closePrice(4d) + .highPrice(4d) + .lowPrice(5d) + .volume(6d) + .amount(7d) + .trades(7) + .build(); + barSeries.addBar(bar0); + barSeries.addBar(bar1); + barSeries.addBar(bar2); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries, "newName"); @@ -74,17 +100,42 @@ public void testAggregateWithNewName() { @Test public void testAggregateWithTheSameName() { - final List bars = new LinkedList<>(); + final BarSeries barSeries = new MockBarSeriesBuilder().withName("name").build(); final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 6d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 2d, 3d, 3d, 4d, 5d, 6d, 7, numFunction); - final Bar bar2 = new MockBar(time.plusDays(2), 3d, 4d, 4d, 5d, 6d, 7d, 7, numFunction); - bars.add(bar0); - bars.add(bar1); - bars.add(bar2); - - final BarSeries barSeries = new BaseBarSeries("name", bars); + var bar0 = barSeries.barBuilder() + .endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .volume(5d) + .amount(6d) + .trades(7) + .build(); + var bar1 = barSeries.barBuilder() + .endTime(time.plusDays(1)) + .openPrice(2d) + .closePrice(3d) + .highPrice(3d) + .lowPrice(4d) + .volume(5d) + .amount(6d) + .trades(7) + .build(); + var bar2 = barSeries.barBuilder() + .endTime(time.plusDays(2)) + .openPrice(3d) + .closePrice(4d) + .highPrice(4d) + .lowPrice(5d) + .volume(6d) + .amount(7d) + .trades(7) + .build(); + barSeries.addBar(bar0); + barSeries.addBar(bar1); + barSeries.addBar(bar2); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries); @@ -112,4 +163,4 @@ public List aggregate(List bars) { return aggregated; } } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/aggregator/DurationBarAggregatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/aggregator/DurationBarAggregatorTest.java index ee39f9be1..5343486c2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/aggregator/DurationBarAggregatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/aggregator/DurationBarAggregatorTest.java @@ -31,20 +31,20 @@ import java.time.ZonedDateTime; import java.util.LinkedList; import java.util.List; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DurationBarAggregatorTest extends AbstractIndicatorTest { - public DurationBarAggregatorTest(Function numFunction) { - super(numFunction); + public DurationBarAggregatorTest(NumFactory numFactory) { + super(numFactory); } private List getOneDayBars() { @@ -52,28 +52,156 @@ private List getOneDayBars() { final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); // days 1 - 5 - bars.add(new MockBar(time, 1d, 2d, 3d, 4d, 5d, 6d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(1), 2d, 3d, 3d, 4d, 5d, 6d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(2), 3d, 4d, 4d, 5d, 6d, 7d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(3), 4d, 5d, 6d, 5d, 7d, 8d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(4), 5d, 9d, 3d, 11d, 2d, 6d, 7, numFunction)); + bars.add(new MockBarBuilder(numFactory).endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(6d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(1)) + .openPrice(2d) + .closePrice(3d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(6d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(2)) + .openPrice(3d) + .closePrice(4d) + .highPrice(4d) + .lowPrice(5d) + .amount(6d) + .volume(7d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(3)) + .openPrice(4d) + .closePrice(5d) + .highPrice(6d) + .lowPrice(5d) + .amount(7d) + .volume(8d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(4)) + .openPrice(5d) + .closePrice(9d) + .highPrice(3d) + .lowPrice(11d) + .amount(2d) + .volume(6d) + .trades(7) + .build()); // days 6 - 10 - bars.add(new MockBar(time.plusDays(5), 6d, 10d, 9d, 4d, 8d, 3d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(6), 3d, 3d, 4d, 95d, 21d, 74d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(7), 4d, 7d, 63d, 59d, 56d, 89d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(8), 5d, 93d, 3d, 21d, 29d, 62d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(9), 6d, 10d, 91d, 43d, 84d, 32d, 7, numFunction)); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(5)) + .openPrice(6d) + .closePrice(10d) + .highPrice(9d) + .lowPrice(4d) + .amount(8d) + .volume(3d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(6)) + .openPrice(3d) + .closePrice(3d) + .highPrice(4d) + .lowPrice(95d) + .amount(21d) + .volume(74d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(7)) + .openPrice(4d) + .closePrice(7d) + .highPrice(63d) + .lowPrice(59d) + .amount(56d) + .volume(89d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(8)) + .openPrice(5d) + .closePrice(93d) + .highPrice(3d) + .lowPrice(21d) + .amount(29d) + .volume(62d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(9)) + .openPrice(6d) + .closePrice(10d) + .highPrice(91d) + .lowPrice(43d) + .amount(84d) + .volume(32d) + .trades(7) + .build()); // days 11 - 15 - bars.add(new MockBar(time.plusDays(10), 4d, 10d, 943d, 49d, 8d, 43d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(11), 3d, 3d, 43d, 92d, 21d, 784d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(12), 4d, 74d, 53d, 52d, 56d, 89d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(13), 5d, 93d, 31d, 221d, 29d, 62d, 7, numFunction)); - bars.add(new MockBar(time.plusDays(14), 6d, 10d, 991d, 43d, 84d, 32d, 7, numFunction)); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(10)) + .openPrice(4d) + .closePrice(10d) + .highPrice(943d) + .lowPrice(49d) + .amount(8d) + .volume(43d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(11)) + .openPrice(3d) + .closePrice(3d) + .highPrice(43d) + .lowPrice(92d) + .amount(21d) + .volume(784d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(12)) + .openPrice(4d) + .closePrice(74d) + .highPrice(53d) + .lowPrice(52d) + .amount(56d) + .volume(89d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(13)) + .openPrice(5d) + .closePrice(93d) + .highPrice(31d) + .lowPrice(221d) + .amount(29d) + .volume(62d) + .trades(7) + .build()); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(14)) + .openPrice(6d) + .closePrice(10d) + .highPrice(991d) + .lowPrice(43d) + .amount(84d) + .volume(32d) + .trades(7) + .build()); // day 16 - bars.add(new MockBar(time.plusDays(15), 6d, 108d, 1991d, 433d, 847d, 322d, 7, numFunction)); + bars.add(new MockBarBuilder(numFactory).endTime(time.plusDays(15)) + .openPrice(6d) + .closePrice(108d) + .highPrice(1991d) + .lowPrice(433d) + .amount(847d) + .volume(322d) + .trades(7) + .build()); return bars; } @@ -154,11 +282,37 @@ public void upscaledTo10DayBarsNotOnlyFinalBars() { @Test public void testWithGapsInSeries() { ZonedDateTime now = ZonedDateTime.now(); - BarSeries barSeries = new BaseBarSeries(); + BarSeries barSeries = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); - barSeries.addBar(Duration.ofMinutes(1), now.plusMinutes(1), 1, 1, 1, 2, 1); - barSeries.addBar(Duration.ofMinutes(1), now.plusMinutes(2), 1, 1, 1, 3, 1); - barSeries.addBar(Duration.ofMinutes(1), now.plusMinutes(60), 1, 1, 1, 1, 1); + barSeries.barBuilder() + .timePeriod(Duration.ofMinutes(1)) + .endTime(now.plusMinutes(1)) + .openPrice(1) + .highPrice(1) + .closePrice(2) + .lowPrice(1) + .volume(1) + .add(); + barSeries.barBuilder() + .timePeriod(Duration.ofMinutes(1)) + .endTime(now.plusMinutes(2)) + .openPrice(1) + .highPrice(1) + .closePrice(3) + .lowPrice(1) + .volume(1) + .add(); + ; + barSeries.barBuilder() + .timePeriod(Duration.ofMinutes(1)) + .endTime(now.plusMinutes(60)) + .openPrice(1) + .highPrice(1) + .closePrice(1) + .lowPrice(1) + .volume(1) + .add(); + ; BarSeries aggregated2MinSeries = new BaseBarSeriesAggregator( new DurationBarAggregator(Duration.ofMinutes(2), false)).aggregate(barSeries, ""); diff --git a/ta4j-core/src/test/java/org/ta4j/core/analysis/CashFlowTest.java b/ta4j-core/src/test/java/org/ta4j/core/analysis/CashFlowTest.java index 3dedaeaa9..e6a756315 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/analysis/CashFlowTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/analysis/CashFlowTest.java @@ -27,29 +27,28 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.util.Collections; -import java.util.function.Function; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Indicator; import org.ta4j.core.Trade; -import org.ta4j.core.TradingRecord; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CashFlowTest extends AbstractIndicatorTest, Num> { - public CashFlowTest(Function numFunction) { - super(numFunction); + public CashFlowTest(NumFactory numFactory) { + super(numFactory); } @Test public void cashFlowSize() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); - CashFlow cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1d, 2d, 3d, 4d, 5d) + .build(); + var cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); assertEquals(5, cashFlow.getSize()); assertNumEquals(1, cashFlow.getValue(0)); @@ -62,11 +61,10 @@ public void cashFlowSize() { @Test public void cashFlowBuyWithOnlyOnePosition() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), - Trade.sellAt(1, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 2d).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(1, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(2, cashFlow.getValue(1)); @@ -74,12 +72,14 @@ public void cashFlowBuyWithOnlyOnePosition() { @Test public void cashFlowWithSellAndBuyTrades() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 2, 1, 3, 5, 6, 3, 20); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), - Trade.sellAt(1, sampleBarSeries), Trade.buyAt(3, sampleBarSeries), Trade.sellAt(4, sampleBarSeries), - Trade.sellAt(5, sampleBarSeries), Trade.buyAt(6, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(2, 1, 3, 5, 6, 3, 20) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(1, sampleBarSeries), + Trade.buyAt(3, sampleBarSeries), Trade.sellAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries), + Trade.buyAt(6, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals("0.5", cashFlow.getValue(1)); @@ -92,11 +92,12 @@ public void cashFlowWithSellAndBuyTrades() { @Test public void cashFlowSell() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1, 2, 4, 8, 16, 32); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(2, sampleBarSeries), - Trade.buyAt(3, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 4, 8, 16, 32) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(2, sampleBarSeries), Trade.buyAt(3, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(1, cashFlow.getValue(1)); @@ -108,12 +109,14 @@ public void cashFlowSell() { @Test public void cashFlowShortSell() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1, 2, 4, 8, 16, 32); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), - Trade.sellAt(2, sampleBarSeries), Trade.sellAt(2, sampleBarSeries), Trade.buyAt(4, sampleBarSeries), - Trade.buyAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 4, 8, 16, 32) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(2, sampleBarSeries), + Trade.sellAt(2, sampleBarSeries), Trade.buyAt(4, sampleBarSeries), Trade.buyAt(4, sampleBarSeries), + Trade.sellAt(5, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(2, cashFlow.getValue(1)); @@ -125,11 +128,10 @@ public void cashFlowShortSell() { @Test public void cashFlowShortSellWith20PercentGain() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 110, 100, 90, 80); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), - Trade.buyAt(3, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(110, 100, 90, 80).build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), Trade.buyAt(3, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(1, cashFlow.getValue(1)); @@ -139,11 +141,10 @@ public void cashFlowShortSellWith20PercentGain() { @Test public void cashFlowShortSellWith20PercentLoss() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 90, 100, 110, 120); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), - Trade.buyAt(3, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(90, 100, 110, 120).build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), Trade.buyAt(3, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(1, cashFlow.getValue(1)); @@ -153,12 +154,12 @@ public void cashFlowShortSellWith20PercentLoss() { @Test public void cashFlowShortSellWith100PercentLoss() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, - 200); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), - Trade.buyAt(11, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(1, sampleBarSeries), Trade.buyAt(11, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(1, cashFlow.getValue(1)); @@ -176,11 +177,12 @@ public void cashFlowShortSellWith100PercentLoss() { @Test public void cashFlowShortSellWithOver100PercentLoss() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 100, 150, 200, 210); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, sampleBarSeries), - Trade.buyAt(3, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 150, 200, 210) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(0, sampleBarSeries), Trade.buyAt(3, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(0.5, cashFlow.getValue(1)); @@ -190,11 +192,10 @@ public void cashFlowShortSellWithOver100PercentLoss() { @Test public void cashFlowShortSellBigLossWithNegativeCashFlow() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 3, 20); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, sampleBarSeries), - Trade.buyAt(1, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(3, 20).build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(0, sampleBarSeries), Trade.buyAt(1, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(-4.6667, cashFlow.getValue(1)); @@ -202,9 +203,8 @@ public void cashFlowShortSellBigLossWithNegativeCashFlow() { @Test public void cashFlowValueWithOnlyOnePositionAndAGapBefore() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 1d, 2d); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(1, sampleBarSeries), - Trade.sellAt(2, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 1d, 2d).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(1, sampleBarSeries), Trade.sellAt(2, sampleBarSeries)); CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); @@ -215,11 +215,10 @@ public void cashFlowValueWithOnlyOnePositionAndAGapBefore() { @Test public void cashFlowValueWithOnlyOnePositionAndAGapAfter() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 2d); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), - Trade.sellAt(1, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 2d, 2d).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(1, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertEquals(3, cashFlow.getSize()); assertNumEquals(1, cashFlow.getValue(0)); @@ -229,11 +228,13 @@ public void cashFlowValueWithOnlyOnePositionAndAGapAfter() { @Test public void cashFlowValueWithTwoPositionsAndLongTimeWithoutTrades() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 4d, 8d, 16d, 32d); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(1, sampleBarSeries), - Trade.sellAt(2, sampleBarSeries), Trade.buyAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1d, 2d, 4d, 8d, 16d, 32d) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(1, sampleBarSeries), Trade.sellAt(2, sampleBarSeries), + Trade.buyAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(1, cashFlow.getValue(1)); @@ -246,13 +247,14 @@ public void cashFlowValueWithTwoPositionsAndLongTimeWithoutTrades() { @Test public void cashFlowValue() { // First sample series - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 3d, 2d, 5d, 1000d, 5000d, 0.0001d, 4d, 7d, 6d, 7d, - 8d, 5d, 6d); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), - Trade.sellAt(2, sampleBarSeries), Trade.buyAt(6, sampleBarSeries), Trade.sellAt(8, sampleBarSeries), - Trade.buyAt(9, sampleBarSeries), Trade.sellAt(11, sampleBarSeries)); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(3d, 2d, 5d, 1000d, 5000d, 0.0001d, 4d, 7d, 6d, 7d, 8d, 5d, 6d) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(2, sampleBarSeries), + Trade.buyAt(6, sampleBarSeries), Trade.sellAt(8, sampleBarSeries), Trade.buyAt(9, sampleBarSeries), + Trade.sellAt(11, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(0)); assertNumEquals(2d / 3, cashFlow.getValue(1)); @@ -269,11 +271,13 @@ public void cashFlowValue() { assertNumEquals(5d / 3 * 6d / 4 * 5d / 7, cashFlow.getValue(12)); // Second sample series - sampleBarSeries = new MockBarSeries(numFunction, 5d, 6d, 3d, 7d, 8d, 6d, 10d, 15d, 6d); + sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(5d, 6d, 3d, 7d, 8d, 6d, 10d, 15d, 6d) + .build(); tradingRecord = new BaseTradingRecord(Trade.buyAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries), Trade.buyAt(6, sampleBarSeries), Trade.sellAt(8, sampleBarSeries)); - CashFlow flow = new CashFlow(sampleBarSeries, tradingRecord); + var flow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, flow.getValue(0)); assertNumEquals(1, flow.getValue(1)); assertNumEquals(1, flow.getValue(2)); @@ -287,8 +291,10 @@ public void cashFlowValue() { @Test public void cashFlowValueWithNoPositions() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 3d, 2d, 5d, 4d, 7d, 6d, 7d, 8d, 5d, 6d); - CashFlow cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(3d, 2d, 5d, 4d, 7d, 6d, 7d, 8d, 5d, 6d) + .build(); + var cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); assertNumEquals(1, cashFlow.getValue(4)); assertNumEquals(1, cashFlow.getValue(7)); assertNumEquals(1, cashFlow.getValue(9)); @@ -297,10 +303,12 @@ public void cashFlowValueWithNoPositions() { @Test public void reallyLongCashFlow() { int size = 1000000; - BarSeries sampleBarSeries = new MockBarSeries(Collections.nCopies(size, new MockBar(10, numFunction))); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(Collections.nCopies(size, 10d)) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(size - 1, sampleBarSeries)); - CashFlow cashFlow = new CashFlow(sampleBarSeries, tradingRecord); + var cashFlow = new CashFlow(sampleBarSeries, tradingRecord); assertNumEquals(1, cashFlow.getValue(size - 1)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java b/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java index 7145f04fd..03483dcfb 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java @@ -26,32 +26,31 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; -import org.ta4j.core.Indicator; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; -public class ReturnsTest extends AbstractIndicatorTest, Num> { +public class ReturnsTest { - public ReturnsTest(Function numFunction) { - super(DoubleNum::valueOf); - } + private NumFactory numFactory = new DoubleNumFactory(); @Test public void returnSize() { for (Returns.ReturnType type : Returns.ReturnType.values()) { // No return at index 0 - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1d, 2d, 3d, 4d, 5d) + .build(); Returns returns = new Returns(sampleBarSeries, new BaseTradingRecord(), type); assertEquals(4, returns.getSize()); } @@ -59,7 +58,7 @@ public void returnSize() { @Test public void singleReturnPositionArith() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 2d).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(1, sampleBarSeries)); Returns return1 = new Returns(sampleBarSeries, tradingRecord, Returns.ReturnType.ARITHMETIC); @@ -69,7 +68,9 @@ public void singleReturnPositionArith() { @Test public void returnsWithSellAndBuyTrades() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 2, 1, 3, 5, 6, 3, 20); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(2, 1, 3, 5, 6, 3, 20) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, sampleBarSeries), Trade.sellAt(1, sampleBarSeries), Trade.buyAt(3, sampleBarSeries), Trade.sellAt(4, sampleBarSeries), Trade.sellAt(5, sampleBarSeries), Trade.buyAt(6, sampleBarSeries)); @@ -87,7 +88,9 @@ public void returnsWithSellAndBuyTrades() { @Test public void returnsWithGaps() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d, 10d, 11d, 12d); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d, 10d, 11d, 12d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(2, sampleBarSeries), Trade.buyAt(5, sampleBarSeries), Trade.buyAt(8, sampleBarSeries), Trade.sellAt(10, sampleBarSeries)); @@ -110,7 +113,9 @@ public void returnsWithGaps() { @Test public void returnsWithNoPositions() { - BarSeries sampleBarSeries = new MockBarSeries(numFunction, 3d, 2d, 5d, 4d, 7d, 6d, 7d, 8d, 5d, 6d); + var sampleBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(3d, 2d, 5d, 4d, 7d, 6d, 7d, 8d, 5d, 6d) + .build(); Returns returns = new Returns(sampleBarSeries, new BaseTradingRecord(), Returns.ReturnType.LOG); assertNumEquals(NaN.NaN, returns.getValue(0)); assertNumEquals(0, returns.getValue(4)); @@ -120,19 +125,22 @@ public void returnsWithNoPositions() { @Test public void returnsPrecision() { - BarSeries doubleSeries = new MockBarSeries(numFunction, 1.2d, 1.1d); - BarSeries precisionSeries = new MockBarSeries(DecimalNum::valueOf, 1.2d, 1.1d); + var doubleSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1.2d, 1.1d).build(); + BarSeries precisionSeries = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + .withData(1.2d, 1.1d) + .build(); TradingRecord fullRecordDouble = new BaseTradingRecord(); fullRecordDouble.enter(doubleSeries.getBeginIndex(), doubleSeries.getBar(0).getClosePrice(), - doubleSeries.one()); - fullRecordDouble.exit(doubleSeries.getEndIndex(), doubleSeries.getBar(1).getClosePrice(), doubleSeries.one()); + doubleSeries.numFactory().one()); + fullRecordDouble.exit(doubleSeries.getEndIndex(), doubleSeries.getBar(1).getClosePrice(), + doubleSeries.numFactory().one()); TradingRecord fullRecordPrecision = new BaseTradingRecord(); fullRecordPrecision.enter(precisionSeries.getBeginIndex(), precisionSeries.getBar(0).getClosePrice(), - precisionSeries.one()); + precisionSeries.numFactory().one()); fullRecordPrecision.exit(precisionSeries.getEndIndex(), precisionSeries.getBar(1).getClosePrice(), - precisionSeries.one()); + precisionSeries.numFactory().one()); // Return calculation DoubleNum vs PrecisionNum Num arithDouble = new Returns(doubleSeries, fullRecordDouble, Returns.ReturnType.ARITHMETIC).getValue(1); @@ -141,11 +149,11 @@ public void returnsPrecision() { Num logDouble = new Returns(doubleSeries, fullRecordDouble, Returns.ReturnType.LOG).getValue(1); Num logPrecision = new Returns(precisionSeries, fullRecordPrecision, Returns.ReturnType.LOG).getValue(1); - assertNumEquals(arithDouble, DoubleNum.valueOf(-0.08333333333333326)); + assertNumEquals(DoubleNum.valueOf(-0.08333333333333326), arithDouble); assertNumEquals(arithPrecision, DecimalNum.valueOf(1.1).dividedBy(DecimalNum.valueOf(1.2)).minus(DecimalNum.valueOf(1))); - assertNumEquals(logDouble, DoubleNum.valueOf(-0.08701137698962969)); - assertNumEquals(logPrecision, DecimalNum.valueOf("-0.087011376989629766167765901873746")); + assertNumEquals(DoubleNum.valueOf(-0.08701137698962969), logDouble); + assertNumEquals(DecimalNum.valueOf("-0.087011376989629766167765901873746"), logPrecision); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/analysis/cost/LinearTransactionCostModelTest.java b/ta4j-core/src/test/java/org/ta4j/core/analysis/cost/LinearTransactionCostModelTest.java index ead0fe831..f5a499efd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/analysis/cost/LinearTransactionCostModelTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/analysis/cost/LinearTransactionCostModelTest.java @@ -44,6 +44,7 @@ import org.ta4j.core.Trade; import org.ta4j.core.backtest.BacktestExecutor; import org.ta4j.core.backtest.TradeOnCurrentCloseModel; +import org.ta4j.core.mocks.MockBarBuilderFactory; import org.ta4j.core.num.DoubleNum; import org.ta4j.core.num.Num; import org.ta4j.core.reports.TradingStatement; @@ -134,27 +135,47 @@ public void testEquality() { @Test public void testBacktesting() { - BaseBarSeries series = new BaseBarSeriesBuilder().withName("CostModel test").build(); + BaseBarSeries series = new BaseBarSeriesBuilder().withName("CostModel test") + .withBarBuilderFactory(new MockBarBuilderFactory()) + .build(); ZonedDateTime now = ZonedDateTime.now(); - Num one = series.one(); - Num two = series.numOf(2); - Num three = series.numOf(3); - Num four = series.numOf(4); - series.addBar(now, one, one, one, one, one); - series.addBar(now.plusSeconds(1), two, two, two, two, two); - series.addBar(now.plusSeconds(2), three, three, three, three, three); - series.addBar(now.plusSeconds(3), four, four, four, four, four); + Num one = series.numFactory().one(); + Num two = series.numFactory().numOf(2); + Num three = series.numFactory().numOf(3); + Num four = series.numFactory().numOf(4); + series.barBuilder().endTime(now).openPrice(one).closePrice(one).highPrice(one).lowPrice(one).add(); + series.barBuilder() + .endTime(now.plusSeconds(1)) + .openPrice(two) + .closePrice(two) + .highPrice(two) + .lowPrice(two) + .add(); + series.barBuilder() + .endTime(now.plusSeconds(2)) + .openPrice(three) + .closePrice(three) + .highPrice(three) + .lowPrice(three) + .add(); + series.barBuilder() + .endTime(now.plusSeconds(3)) + .openPrice(four) + .closePrice(four) + .highPrice(four) + .lowPrice(four) + .add(); Rule entryRule = new FixedRule(0, 2); Rule exitRule = new FixedRule(1, 3); List strategies = new LinkedList<>(); strategies.add(new BaseStrategy("Cost model test strategy", entryRule, exitRule)); - Num orderFee = series.numOf(new BigDecimal("0.0026")); + Num orderFee = series.numFactory().numOf(new BigDecimal("0.0026")); BacktestExecutor executor = new BacktestExecutor(series, new LinearTransactionCostModel(orderFee.doubleValue()), new ZeroCostModel(), new TradeOnCurrentCloseModel()); - Num amount = series.numOf(25); + Num amount = series.numFactory().numOf(25); TradingStatement strategyResult = executor.execute(strategies, amount).get(0); Num firstPositionBuy = one.plus(one.multipliedBy(orderFee)); @@ -169,4 +190,4 @@ public void testBacktesting() { assertEquals(overallProfit, strategyResult.getPerformanceReport().getTotalProfit()); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/backtest/BarSeriesManagerTest.java b/ta4j-core/src/test/java/org/ta4j/core/backtest/BarSeriesManagerTest.java index a9c40634d..ee988f1dd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/backtest/BarSeriesManagerTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/backtest/BarSeriesManagerTest.java @@ -26,11 +26,9 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.List; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; @@ -42,8 +40,9 @@ import org.ta4j.core.Trade.TradeType; import org.ta4j.core.TradingRecord; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.FixedRule; public class BarSeriesManagerTest extends AbstractIndicatorTest { @@ -56,24 +55,26 @@ public class BarSeriesManagerTest extends AbstractIndicatorTest private final Num HUNDRED = numOf(100); - public BarSeriesManagerTest(Function numFunction) { - super(numFunction); + public BarSeriesManagerTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { final DateTimeFormatter dtf = DateTimeFormatter.ISO_ZONED_DATE_TIME; - seriesForRun = new MockBarSeries(numFunction, new double[] { 1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d }, - new ZonedDateTime[] { ZonedDateTime.parse("2013-01-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2013-08-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2013-10-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2013-12-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2014-02-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2015-01-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2015-08-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2015-10-01T00:00:00-05:00", dtf), - ZonedDateTime.parse("2015-12-01T00:00:00-05:00", dtf) }); + seriesForRun = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2013-01-01T00:00:00-05:00", dtf)).closePrice(1d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2013-08-01T00:00:00-05:00", dtf)).closePrice(2d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2013-10-01T00:00:00-05:00", dtf)).closePrice(3d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2013-12-01T00:00:00-05:00", dtf)).closePrice(4d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2014-02-01T00:00:00-05:00", dtf)).closePrice(5d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2015-01-01T00:00:00-05:00", dtf)).closePrice(6d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2015-08-01T00:00:00-05:00", dtf)).closePrice(7d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2015-10-01T00:00:00-05:00", dtf)).closePrice(8d).add(); + seriesForRun.barBuilder().endTime(ZonedDateTime.parse("2015-12-01T00:00:00-05:00", dtf)).closePrice(7d).add(); + manager = new BarSeriesManager(seriesForRun, new TradeOnCurrentCloseModel()); strategy = new BaseStrategy(new FixedRule(0, 2, 3, 6), new FixedRule(1, 4, 7, 8)); @@ -82,7 +83,9 @@ public void setUp() { @Test public void runOnWholeSeries() { - BarSeries series = new MockBarSeries(numFunction, 20d, 40d, 60d, 10d, 30d, 50d, 0d, 20d, 40d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(20d, 40d, 60d, 10d, 30d, 50d, 0d, 20d, 40d) + .build(); manager = new BarSeriesManager(series, new TradeOnCurrentCloseModel()); List allPositions = manager.run(strategy).getPositions(); assertEquals(2, allPositions.size()); @@ -90,7 +93,9 @@ public void runOnWholeSeries() { @Test public void runOnWholeSeriesWithAmount() { - BarSeries series = new MockBarSeries(numFunction, 20d, 40d, 60d, 10d, 30d, 50d, 0d, 20d, 40d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(20d, 40d, 60d, 10d, 30d, 50d, 0d, 20d, 40d) + .build(); manager = new BarSeriesManager(series, new TradeOnCurrentCloseModel()); List allPositions = manager.run(strategy, TradeType.BUY, HUNDRED).getPositions(); @@ -163,12 +168,19 @@ public void runBetweenIndexes() { @Test public void runOnSeriesSlices() { - ZonedDateTime dateTime = ZonedDateTime.of(2000, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault()); - BarSeries series = new MockBarSeries(numFunction, new double[] { 1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d, 10d }, - new ZonedDateTime[] { dateTime.withYear(2000), dateTime.withYear(2000), dateTime.withYear(2001), - dateTime.withYear(2001), dateTime.withYear(2002), dateTime.withYear(2002), - dateTime.withYear(2002), dateTime.withYear(2003), dateTime.withYear(2004), - dateTime.withYear(2005) }); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + series.barBuilder().closePrice(1d).add(); + series.barBuilder().closePrice(2d).add(); + series.barBuilder().closePrice(3d).add(); + series.barBuilder().closePrice(4d).add(); + series.barBuilder().closePrice(5d).add(); + series.barBuilder().closePrice(6d).add(); + series.barBuilder().closePrice(7d).add(); + series.barBuilder().closePrice(8d).add(); + series.barBuilder().closePrice(9d).add(); + series.barBuilder().closePrice(10d).add(); + manager = new BarSeriesManager(series, new TradeOnCurrentCloseModel()); Strategy aStrategy = new BaseStrategy(new FixedRule(0, 3, 5, 7), new FixedRule(2, 4, 6, 9)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractAnalysisCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractAnalysisCriterionTest.java index 8223d0e08..ed16ffdf7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractAnalysisCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractAnalysisCriterionTest.java @@ -27,7 +27,6 @@ import java.util.ArrayList; import java.util.List; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; @@ -37,8 +36,8 @@ import org.ta4j.core.backtest.BarSeriesManager; import org.ta4j.core.backtest.TradeOnCurrentCloseModel; import org.ta4j.core.criteria.pnl.ReturnCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.BooleanRule; import org.ta4j.core.rules.FixedRule; @@ -50,31 +49,31 @@ public class AbstractAnalysisCriterionTest extends AbstractCriterionTest { private List strategies; - public AbstractAnalysisCriterionTest(Function numFunction) { - super(params -> new ReturnCriterion(), numFunction); + public AbstractAnalysisCriterionTest(NumFactory numFactory) { + super(params -> new ReturnCriterion(), numFactory); } @Before public void setUp() { alwaysStrategy = new BaseStrategy(BooleanRule.TRUE, BooleanRule.TRUE); buyAndHoldStrategy = new BaseStrategy(new FixedRule(0), new FixedRule(4)); - strategies = new ArrayList(); + strategies = new ArrayList<>(); strategies.add(alwaysStrategy); strategies.add(buyAndHoldStrategy); } @Test public void bestShouldBeAlwaysOperateOnProfit() { - MockBarSeries series = new MockBarSeries(numFunction, 6.0, 9.0, 6.0, 6.0); - BarSeriesManager manager = new BarSeriesManager(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(6.0, 9.0, 6.0, 6.0).build(); + var manager = new BarSeriesManager(series); Strategy bestStrategy = getCriterion().chooseBest(manager, TradeType.BUY, strategies); assertEquals(alwaysStrategy, bestStrategy); } @Test public void bestShouldBeBuyAndHoldOnLoss() { - MockBarSeries series = new MockBarSeries(numFunction, 6.0, 3.0, 6.0, 6.0); - BarSeriesManager manager = new BarSeriesManager(series, new TradeOnCurrentCloseModel()); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(6.0, 3.0, 6.0, 6.0).build(); + var manager = new BarSeriesManager(series, new TradeOnCurrentCloseModel()); Strategy bestStrategy = getCriterion().chooseBest(manager, TradeType.BUY, strategies); assertEquals(buyAndHoldStrategy, bestStrategy); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java index 48653da72..d9a67b8d9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java @@ -23,22 +23,21 @@ */ package org.ta4j.core.criteria; -import java.util.Arrays; import java.util.List; -import java.util.function.Function; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.CriterionFactory; -import org.ta4j.core.num.DecimalNum; -import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DecimalNumFactory; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; @RunWith(Parameterized.class) public abstract class AbstractCriterionTest { - protected final Function numFunction; + protected final NumFactory numFactory; protected final OpenedPositionUtils openedPositionUtils = new OpenedPositionUtils(); private final CriterionFactory factory; @@ -48,14 +47,14 @@ public abstract class AbstractCriterionTest { * @param factory CriterionFactory for building an AnalysisCriterion given * parameters */ - public AbstractCriterionTest(CriterionFactory factory, Function numFunction) { + public AbstractCriterionTest(CriterionFactory factory, NumFactory numFactory) { this.factory = factory; - this.numFunction = numFunction; + this.numFactory = numFactory; } @Parameterized.Parameters(name = "Test Case: {index} (0=DoubleNum, 1=DecimalNum)") - public static List> function() { - return Arrays.asList(DoubleNum::valueOf, DecimalNum::valueOf); + public static List function() { + return List.of(new DoubleNumFactory(), new DecimalNumFactory()); } /** @@ -69,7 +68,7 @@ public AnalysisCriterion getCriterion(Object... params) { } public Num numOf(Number n) { - return numFunction.apply(n); + return numFactory.numOf(n); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/AverageReturnPerBarCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/AverageReturnPerBarCriterionTest.java index 556a75560..2fe632057 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/AverageReturnPerBarCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/AverageReturnPerBarCriterionTest.java @@ -27,27 +27,28 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; +import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class AverageReturnPerBarCriterionTest extends AbstractCriterionTest { - private MockBarSeries series; + private BarSeries series; - public AverageReturnPerBarCriterionTest(Function numFunction) { - super(params -> new AverageReturnPerBarCriterion(), numFunction); + public AverageReturnPerBarCriterionTest(NumFactory numFactory) { + super(params -> new AverageReturnPerBarCriterion(), numFactory); } @Test public void calculateOnlyWithGainPositions() { - series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 105d, 110d, 100d, 95d, 105d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); @@ -56,7 +57,9 @@ public void calculateOnlyWithGainPositions() { @Test public void calculateWithASimplePosition() { - series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 105d, 110d, 100d, 95d, 105d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(110d / 100).pow(numOf(1d / 3)), averageProfit.calculate(series, tradingRecord)); @@ -64,7 +67,7 @@ public void calculateWithASimplePosition() { @Test public void calculateOnlyWithLossPositions() { - series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); @@ -74,7 +77,9 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateWithLosingAShortPositions() { - series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 105d, 110d, 100d, 95d, 105d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(2, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(90d / 100).pow(numOf(1d / 3)), averageProfit.calculate(series, tradingRecord)); @@ -82,14 +87,14 @@ public void calculateWithLosingAShortPositions() { @Test public void calculateWithNoBarsShouldReturn1() { - series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1, averageProfit.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithOnePosition() { - series = new MockBarSeries(numFunction, 100, 105); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 105).build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(105d / 100).pow(numOf(0.5)), average.calculate(series, position)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterionTest.java index b4a240c97..f57c49579 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/EnterAndHoldReturnCriterionTest.java @@ -28,7 +28,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.util.List; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.AnalysisCriterion; @@ -36,21 +35,21 @@ import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.Trade.TradeType; -import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class EnterAndHoldReturnCriterionTest extends AbstractCriterionTest { - public EnterAndHoldReturnCriterionTest(Function numFunction) { + public EnterAndHoldReturnCriterionTest(NumFactory numFactory) { super(params -> params.length == 0 ? new EnterAndHoldReturnCriterion() - : new EnterAndHoldReturnCriterion((TradeType) params[0]), numFunction); + : new EnterAndHoldReturnCriterion((TradeType) params[0]), numFactory); } @Test public void calculateWithEmpty() { - MockBarSeries series = new MockBarSeries(numFunction, List.of()); - TradingRecord tradingRecord = new BaseTradingRecord(); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(List.of()).build(); + var tradingRecord = new BaseTradingRecord(); AnalysisCriterion buyAndHold = getCriterion(); AnalysisCriterion sellAndHold = getCriterion(TradeType.SELL); @@ -64,8 +63,10 @@ public void calculateWithEmpty() { @Test public void calculateOnlyWithGainPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); @@ -77,8 +78,8 @@ public void calculateOnlyWithGainPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); @@ -90,7 +91,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0.7, buyAndHold.calculate(series, new BaseTradingRecord())); @@ -101,7 +102,7 @@ public void calculateWithNoPositions() { @Test public void calculateWithOnePositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 105).build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(105d / 100, buyAndHold.calculate(series, position)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectancyCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectancyCriterionTest.java index 7b536ef2a..560218585 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectancyCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectancyCriterionTest.java @@ -27,25 +27,25 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ExpectancyCriterionTest extends AbstractCriterionTest { - public ExpectancyCriterionTest(Function numFunction) { - super(params -> new ExpectancyCriterion(), numFunction); + public ExpectancyCriterionTest(NumFactory numFactory) { + super(params -> new ExpectancyCriterion(), numFactory); } @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 110, 120, 130, 150, 160); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 120, 130, 150, 160) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -55,7 +55,9 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateWithMixedPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 110, 80, 130, 150, 160); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 80, 130, 150, 160) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -65,7 +67,7 @@ public void calculateWithMixedPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 80, 70, 60, 50); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 80, 70, 60, 50).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -75,7 +77,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 160, 140, 120, 100, 80, 60); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(160, 140, 120, 100, 80, 60).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -85,7 +87,7 @@ public void calculateProfitWithShortPositions() { @Test public void calculateProfitWithMixedShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 160, 200, 120, 100, 80, 60); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(160, 200, 120, 100, 80, 60).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -102,7 +104,7 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java index c8f024403..83eac91d0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java @@ -29,44 +29,49 @@ import java.util.Collections; import java.util.List; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; import org.junit.Test; import org.ta4j.core.AnalysisCriterion; +import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DoubleNumFactory; +import org.ta4j.core.num.NumFactory; -public class ExpectedShortfallCriterionTest extends AbstractCriterionTest { - private MockBarSeries series; +public class ExpectedShortfallCriterionTest { + private BarSeries series; - public ExpectedShortfallCriterionTest(Function numFunction) { - // LOG returns requre DoubleNum implementation - super(params -> new ExpectedShortfallCriterion(0.95), DoubleNum::valueOf); + private NumFactory numFactory = new DoubleNumFactory(); + + private ExpectedShortfallCriterion getCriterion() { + return new ExpectedShortfallCriterion(0.95); } @Test public void calculateOnlyWithGainPositions() { - series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 105d, 106d, 107d, 108d, 115d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); + assertNumEquals(numFactory.zero(), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateWithASimplePosition() { // if only one position in tail, VaR = ES - series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 104d, 90d, 100d, 95d, 105d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series)); AnalysisCriterion esCriterion = getCriterion(); - assertNumEquals(numOf(Math.log(90d / 104)), esCriterion.calculate(series, tradingRecord)); + assertNumEquals(numFactory.numOf(Math.log(90d / 104)), esCriterion.calculate(series, tradingRecord)); } @Test @@ -77,32 +82,32 @@ public void calculateOnlyWithLossPosition() { .boxed() .sorted(Collections.reverseOrder()) .collect(Collectors.toList()); - series = new MockBarSeries(numFunction, prices); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(prices).build(); Position position = new Position(Trade.buyAt(series.getBeginIndex(), series), Trade.sellAt(series.getEndIndex(), series)); AnalysisCriterion esCriterion = getCriterion(); - assertNumEquals(numOf(-0.35835189384561106), esCriterion.calculate(series, position)); + assertNumEquals(numFactory.numOf(-0.35835189384561106), esCriterion.calculate(series, position)); } @Test public void calculateWithNoBarsShouldReturn0() { - series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100d, 95d, 100d, 80d, 85d, 70d).build(); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); + assertNumEquals(numFactory.numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithBuyAndHold() { - series = new MockBarSeries(numFunction, 100d, 99d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100d, 99d).build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, position)); + assertNumEquals(numFactory.numOf(Math.log(99d / 100)), varCriterion.calculate(series, position)); } @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); - assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); - assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); + assertTrue(criterion.betterThan(numFactory.numOf(-0.1), numFactory.numOf(-0.2))); + assertFalse(criterion.betterThan(numFactory.numOf(-0.1), numFactory.numOf(0.0))); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/LinearTransactionCostCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/LinearTransactionCostCriterionTest.java index 5732aba1b..43f83637c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/LinearTransactionCostCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/LinearTransactionCostCriterionTest.java @@ -27,26 +27,24 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.ExternalCriterionTest; import org.ta4j.core.Position; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LinearTransactionCostCriterionTest extends AbstractCriterionTest { private final ExternalCriterionTest xls; - public LinearTransactionCostCriterionTest(Function numFunction) throws Exception { + public LinearTransactionCostCriterionTest(NumFactory numFactory) { super(params -> new LinearTransactionCostCriterion((double) params[0], (double) params[1], (double) params[2]), - numFunction); - xls = new XLSCriterionTest(this.getClass(), "LTC.xls", 16, 6, numFunction); + numFactory); + xls = new XLSCriterionTest(this.getClass(), "LTC.xls", 16, 6, numFactory); } @Test @@ -66,7 +64,9 @@ public void externalData() throws Exception { @Test public void dummyData() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 150, 200, 100, 50, 100); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 150, 200, 100, 50, 100) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; @@ -87,7 +87,9 @@ public void dummyData() { @Test public void fixedCost() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; @@ -108,7 +110,7 @@ public void fixedCost() { @Test public void fixedCostWithOnePosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); Position position = new Position(); Num criterion; @@ -130,7 +132,7 @@ public void fixedCostWithOnePosition() { @Test public void betterThan() { - AnalysisCriterion criterion = new LinearTransactionCostCriterion(1000, 0.5); + var criterion = new LinearTransactionCostCriterion(1000, 0.5); assertTrue(criterion.betterThan(numOf(3.1), numOf(4.2))); assertFalse(criterion.betterThan(numOf(2.1), numOf(1.9))); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/MaximumDrawdownCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/MaximumDrawdownCriterionTest.java index 23958718d..0bda05423 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/MaximumDrawdownCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/MaximumDrawdownCriterionTest.java @@ -27,25 +27,23 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class MaximumDrawdownCriterionTest extends AbstractCriterionTest { - public MaximumDrawdownCriterionTest(Function numFunction) { - super(params -> new MaximumDrawdownCriterion(), numFunction); + public MaximumDrawdownCriterionTest(NumFactory numFactory) { + super(params -> new MaximumDrawdownCriterion(), numFactory); } @Test public void calculateWithNoTrades() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 6, 5, 20, 3).build(); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); @@ -53,7 +51,7 @@ public void calculateWithNoTrades() { @Test public void calculateWithOnlyGains() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 6, 8, 20, 3).build(); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -63,7 +61,7 @@ public void calculateWithOnlyGains() { @Test public void calculateWithGainsAndLosses() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 6, 5, 20, 3).build(); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(3, series), Trade.sellAt(4, series), Trade.buyAt(5, series), Trade.sellAt(6, series)); @@ -73,14 +71,14 @@ public void calculateWithGainsAndLosses() { @Test public void calculateWithNullSeriesSizeShouldReturn0() { - MockBarSeries series = new MockBarSeries(numFunction, new double[] {}); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(new double[] {}).build(); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); } @Test public void withTradesThatSellBeforeBuying() { - MockBarSeries series = new MockBarSeries(numFunction, 2, 1, 3, 5, 6, 3, 20); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(2, 1, 3, 5, 6, 3, 20).build(); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(3, series), Trade.sellAt(4, series), Trade.sellAt(5, series), Trade.buyAt(6, series)); @@ -89,7 +87,7 @@ public void withTradesThatSellBeforeBuying() { @Test public void withSimpleTrades() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 10, 5, 6, 1); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 10, 5, 6, 1).build(); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(2, series), Trade.sellAt(3, series), diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBarsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBarsCriterionTest.java index 6e5b8b036..c4479b054 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBarsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBarsCriterionTest.java @@ -27,26 +27,26 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfBarsCriterionTest extends AbstractCriterionTest { - public NumberOfBarsCriterionTest(Function numFunction) { - super(params -> new NumberOfBarsCriterion(), numFunction); + public NumberOfBarsCriterionTest(NumFactory numFactory) { + super(params -> new NumberOfBarsCriterion(), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(0, numberOfBars.calculate(series, new BaseTradingRecord())); @@ -54,7 +54,9 @@ public void calculateWithNoPositions() { @Test public void calculateWithTwoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -64,7 +66,7 @@ public void calculateWithTwoPositions() { @Test public void calculateWithOnePosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); Position t = new Position(Trade.buyAt(2, series), Trade.sellAt(5, series)); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(4, numberOfBars.calculate(series, t)); @@ -79,6 +81,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterionTest.java index ede2b6716..da72c3bf9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfBreakEvenPositionsCriterionTest.java @@ -27,33 +27,35 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfBreakEvenPositionsCriterionTest extends AbstractCriterionTest { - public NumberOfBreakEvenPositionsCriterionTest(Function numFunction) { - super(params -> new NumberOfBreakEvenPositionsCriterion(), numFunction); + public NumberOfBreakEvenPositionsCriterionTest(NumFactory numFactory) { + super(params -> new NumberOfBreakEvenPositionsCriterion(), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(3, series), Trade.buyAt(1, series), Trade.sellAt(5, series)); @@ -62,7 +64,9 @@ public void calculateWithTwoLongPositions() { @Test public void calculateWithOneLongPosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, position)); @@ -70,7 +74,9 @@ public void calculateWithOneLongPosition() { @Test public void calculateWithTwoShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(3, series), Trade.sellAt(1, series), Trade.buyAt(5, series)); @@ -86,6 +92,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterionTest.java index f3c934569..e130ee258 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfConsecutivePositionsCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.AnalysisCriterion.PositionFilter; @@ -36,18 +34,20 @@ import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfConsecutivePositionsCriterionTest extends AbstractCriterionTest { - public NumberOfConsecutivePositionsCriterionTest(Function numFunction) { - super(params -> new NumberOfConsecutivePositionsCriterion((PositionFilter) params[0]), numFunction); + public NumberOfConsecutivePositionsCriterionTest(NumFactory numFactory) { + super(params -> new NumberOfConsecutivePositionsCriterion((PositionFilter) params[0]), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); assertNumEquals(0, getCriterion(PositionFilter.LOSS).calculate(series, new BaseTradingRecord())); assertNumEquals(0, getCriterion(PositionFilter.PROFIT).calculate(series, new BaseTradingRecord())); @@ -55,12 +55,16 @@ public void calculateWithNoPositions() { @Test public void calculateWithTwoLongPositions() { - MockBarSeries seriesLoss = new MockBarSeries(numFunction, 110, 105, 100, 90, 80, 140); + var seriesLoss = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(110, 105, 100, 90, 80, 140) + .build(); TradingRecord tradingRecordLoss = new BaseTradingRecord(Trade.buyAt(0, seriesLoss), Trade.sellAt(2, seriesLoss), Trade.buyAt(3, seriesLoss), Trade.sellAt(4, seriesLoss)); assertNumEquals(2, getCriterion(PositionFilter.LOSS).calculate(seriesLoss, tradingRecordLoss)); - MockBarSeries seriesProfit = new MockBarSeries(numFunction, 100, 105, 110, 120, 130, 140); + var seriesProfit = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 120, 130, 140) + .build(); TradingRecord tradingRecordProfit = new BaseTradingRecord(Trade.buyAt(1, seriesProfit), Trade.sellAt(3, seriesProfit), Trade.buyAt(3, seriesProfit), Trade.sellAt(4, seriesProfit)); assertNumEquals(2, getCriterion(PositionFilter.PROFIT).calculate(seriesProfit, tradingRecordProfit)); @@ -68,23 +72,31 @@ public void calculateWithTwoLongPositions() { @Test public void calculateWithOneLongPosition() { - MockBarSeries seriesLoss = new MockBarSeries(numFunction, 110, 105, 100, 90, 95, 105); + var seriesLoss = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(110, 105, 100, 90, 95, 105) + .build(); Position positionLoss = new Position(Trade.buyAt(1, seriesLoss), Trade.sellAt(3, seriesLoss)); assertNumEquals(1, getCriterion(PositionFilter.LOSS).calculate(seriesLoss, positionLoss)); - MockBarSeries seriesProfit = new MockBarSeries(numFunction, 100, 105, 110, 120, 95, 105); + var seriesProfit = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 120, 95, 105) + .build(); Position positionProfit = new Position(Trade.buyAt(1, seriesProfit), Trade.sellAt(3, seriesProfit)); assertNumEquals(1, getCriterion(PositionFilter.PROFIT).calculate(seriesProfit, positionProfit)); } @Test public void calculateWithTwoShortPositions() { - MockBarSeries seriesLoss = new MockBarSeries(numFunction, 100, 90, 110, 120, 95, 105); + var seriesLoss = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 90, 110, 120, 95, 105) + .build(); TradingRecord tradingRecordLoss = new BaseTradingRecord(Trade.sellAt(0, seriesLoss), Trade.buyAt(1, seriesLoss), Trade.sellAt(3, seriesLoss), Trade.buyAt(5, seriesLoss)); assertNumEquals(0, getCriterion(PositionFilter.LOSS).calculate(seriesLoss, tradingRecordLoss)); - MockBarSeries seriesProfit = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var seriesProfit = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecordProfit = new BaseTradingRecord(Trade.sellAt(0, seriesProfit), Trade.buyAt(1, seriesProfit), Trade.sellAt(3, seriesProfit), Trade.buyAt(5, seriesProfit)); assertNumEquals(0, getCriterion(PositionFilter.PROFIT).calculate(seriesProfit, tradingRecordProfit)); @@ -103,9 +115,9 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(PositionFilter.LOSS), 0); - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(PositionFilter.PROFIT), 0); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterionTest.java index 0b72dfad5..dc2a3db6f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfLosingPositionsCriterionTest.java @@ -27,33 +27,35 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfLosingPositionsCriterionTest extends AbstractCriterionTest { - public NumberOfLosingPositionsCriterionTest(Function numFunction) { - super(params -> new NumberOfLosingPositionsCriterion(), numFunction); + public NumberOfLosingPositionsCriterionTest(NumFactory numFactory) { + super(params -> new NumberOfLosingPositionsCriterion(), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(1, series), Trade.sellAt(3, series), Trade.buyAt(3, series), Trade.sellAt(4, series)); @@ -62,7 +64,9 @@ public void calculateWithTwoLongPositions() { @Test public void calculateWithOneLongPosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); Position position = new Position(Trade.buyAt(1, series), Trade.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, position)); @@ -70,7 +74,9 @@ public void calculateWithOneLongPosition() { @Test public void calculateWithTwoShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(3, series), Trade.buyAt(5, series)); @@ -86,6 +92,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfPositionsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfPositionsCriterionTest.java index 0bec4ea94..fef486075 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfPositionsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfPositionsCriterionTest.java @@ -27,27 +27,27 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfPositionsCriterionTest extends AbstractCriterionTest { - public NumberOfPositionsCriterionTest(Function numFunction) { + public NumberOfPositionsCriterionTest(NumFactory numFactory) { super(params -> params.length == 0 ? new NumberOfPositionsCriterion() - : new NumberOfPositionsCriterion((boolean) params[0]), numFunction); + : new NumberOfPositionsCriterion((boolean) params[0]), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0, buyAndHold.calculate(series, new BaseTradingRecord())); @@ -55,7 +55,9 @@ public void calculateWithNoPositions() { @Test public void calculateWithTwoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -65,7 +67,9 @@ public void calculateWithTwoPositions() { @Test public void calculateWithOnePosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); Position position = new Position(); AnalysisCriterion positionsCriterion = getCriterion(); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterionTest.java index d350b740f..37b1f4935 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/NumberOfWinningPositionsCriterionTest.java @@ -27,33 +27,35 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class NumberOfWinningPositionsCriterionTest extends AbstractCriterionTest { - public NumberOfWinningPositionsCriterionTest(Function numFunction) { - super(params -> new NumberOfWinningPositionsCriterion(), numFunction); + public NumberOfWinningPositionsCriterionTest(NumFactory numFactory) { + super(params -> new NumberOfWinningPositionsCriterion(), numFactory); } @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -62,7 +64,9 @@ public void calculateWithTwoLongPositions() { @Test public void calculateWithOneLongPosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(2, series)); assertNumEquals(1, getCriterion().calculate(series, position)); @@ -70,7 +74,9 @@ public void calculateWithOneLongPosition() { @Test public void calculateWithTwoShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 110, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(110, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(4, series)); @@ -86,6 +92,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/OpenedPositionUtils.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/OpenedPositionUtils.java index a28164046..2358fdacc 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/OpenedPositionUtils.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/OpenedPositionUtils.java @@ -25,31 +25,32 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.Position; import org.ta4j.core.Trade; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class OpenedPositionUtils { - public void testCalculateOneOpenPositionShouldReturnExpectedValue(Function numFunction, + public void testCalculateOneOpenPositionShouldReturnExpectedValue(NumFactory numFactory, AnalysisCriterion criterion, Num expectedValue) { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); - Position trade = new Position(Trade.TradeType.BUY); - trade.operate(0, series.numOf(2.5), series.one()); + var trade = new Position(Trade.TradeType.BUY); + trade.operate(0, series.numFactory().numOf(2.5), series.numFactory().one()); final Num value = criterion.calculate(series, trade); assertNumEquals(expectedValue, value); } - public void testCalculateOneOpenPositionShouldReturnExpectedValue(Function numFunction, + public void testCalculateOneOpenPositionShouldReturnExpectedValue(NumFactory numFactory, AnalysisCriterion criterion, int expectedValue) { - this.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, criterion, - numFunction.apply(expectedValue)); + this.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, criterion, + numFactory.numOf(expectedValue)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/PositionsRatioCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/PositionsRatioCriterionTest.java index aea281be9..6cb2513f5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/PositionsRatioCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/PositionsRatioCriterionTest.java @@ -27,28 +27,27 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.AnalysisCriterion.PositionFilter; -import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class PositionsRatioCriterionTest extends AbstractCriterionTest { - public PositionsRatioCriterionTest(Function numFunction) { - super(params -> new PositionsRatioCriterion((PositionFilter) params[0]), numFunction); + public PositionsRatioCriterionTest(NumFactory numFactory) { + super(params -> new PositionsRatioCriterion((PositionFilter) params[0]), numFactory); } @Test public void calculate() { - BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 95d, 102d, 105d, 97d, 113d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(3, series), Trade.buyAt(4, series), Trade.sellAt(5, series)); @@ -64,7 +63,9 @@ public void calculate() { @Test public void calculateWithShortPositions() { - BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 95d, 102d, 105d, 97d, 113d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(2, series), Trade.sellAt(3, series), Trade.buyAt(4, series)); @@ -79,7 +80,9 @@ public void calculateWithShortPositions() { @Test public void calculateWithOnePosition() { - BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 95d, 102d, 105d, 97d, 113d) + .build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); // 0 winning position @@ -114,9 +117,9 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(PositionFilter.PROFIT), 0); - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(PositionFilter.LOSS), 0); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ReturnOverMaxDrawdownCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ReturnOverMaxDrawdownCriterionTest.java index 14a5a2133..ce3ce3c09 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ReturnOverMaxDrawdownCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ReturnOverMaxDrawdownCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.AnalysisCriterion; @@ -36,16 +34,17 @@ import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ReturnOverMaxDrawdownCriterionTest extends AbstractCriterionTest { private AnalysisCriterion rrc; - public ReturnOverMaxDrawdownCriterionTest(Function numFunction) { - super(params -> new ReturnOverMaxDrawdownCriterion(), numFunction); + public ReturnOverMaxDrawdownCriterionTest(NumFactory numFactory) { + super(params -> new ReturnOverMaxDrawdownCriterion(), numFactory); } @Before @@ -55,7 +54,9 @@ public void setUp() { @Test public void rewardRiskRatioCriterion() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 95, 100, 90, 95, 80, 120) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(4, series), Trade.buyAt(5, series), Trade.sellAt(7, series)); @@ -68,7 +69,7 @@ public void rewardRiskRatioCriterion() { @Test public void rewardRiskRatioCriterionOnlyWithGain() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 6, 8, 20, 3).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); assertTrue(rrc.calculate(series, tradingRecord).isNaN()); @@ -76,13 +77,15 @@ public void rewardRiskRatioCriterionOnlyWithGain() { @Test public void rewardRiskRatioCriterionWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 6, 8, 20, 3).build(); assertTrue(rrc.calculate(series, new BaseTradingRecord()).isNaN()); } @Test public void withOnePosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 95, 100, 90, 95, 80, 120); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 95, 95, 100, 90, 95, 80, 120) + .build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion ratioCriterion = getCriterion(); @@ -98,7 +101,9 @@ public void betterThan() { @Test public void testNoDrawDownForTradingRecord() { - final MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 95, 100, 90, 95, 80, 120) + .build(); final TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(3, series)); @@ -109,7 +114,9 @@ public void testNoDrawDownForTradingRecord() { @Test public void testNoDrawDownForPosition() { - final MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 95, 100, 90, 95, 80, 120) + .build(); final Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); final Num result = rrc.calculate(series, position); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/SqnCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/SqnCriterionTest.java index 931516479..540a4ae56 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/SqnCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/SqnCriterionTest.java @@ -27,26 +27,26 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class SqnCriterionTest extends AbstractCriterionTest { - public SqnCriterionTest(Function numFunction) { - super(params -> new SqnCriterion(), numFunction); + public SqnCriterionTest(NumFactory numFactory) { + super(params -> new SqnCriterion(), numFactory); } @Test public void calculateWithWinningLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion sqnCriterion = getCriterion(); @@ -55,7 +55,7 @@ public void calculateWithWinningLongPositions() { @Test public void calculateWithLosingLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -65,8 +65,8 @@ public void calculateWithLosingLongPositions() { @Test public void calculateWithOneWinningAndOneLosingLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 195, 100, 80, 85, 70); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 195, 100, 80, 85, 70).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); AnalysisCriterion sqnCriterion = getCriterion(); @@ -75,8 +75,8 @@ public void calculateWithOneWinningAndOneLosingLongPositions() { @Test public void calculateWithWinningShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 90, 100, 95, 95, 100); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 90, 100, 95, 95, 100).build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(3, series)); AnalysisCriterion sqnCriterion = getCriterion(); @@ -85,7 +85,9 @@ public void calculateWithWinningShortPositions() { @Test public void calculateWithLosingShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 110, 100, 105, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 100, 105, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(3, series)); @@ -102,7 +104,7 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java index 7f357346c..1f76236d0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java @@ -27,71 +27,75 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; +import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Position; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DoubleNumFactory; +import org.ta4j.core.num.NumFactory; + +public class ValueAtRiskCriterionTest { + private BarSeries series; -public class ValueAtRiskCriterionTest extends AbstractCriterionTest { - private MockBarSeries series; + private NumFactory numFactory = new DoubleNumFactory(); - public ValueAtRiskCriterionTest(Function numFunction) { - // LOG returns requre DoubleNum implementation - super(params -> new ValueAtRiskCriterion(0.95), DoubleNum::valueOf); + private AnalysisCriterion getCriterion() { + return new ValueAtRiskCriterion(0.95); } @Test public void calculateOnlyWithGainPositions() { - series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 105d, 106d, 107d, 108d, 115d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); + assertNumEquals(numFactory.zero(), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateWithASimplePosition() { - series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100d, 104d, 90d, 100d, 95d, 105d) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(Math.log(90d / 104)), varCriterion.calculate(series, tradingRecord)); + assertNumEquals(numFactory.numOf(Math.log(90d / 104)), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossPositions() { - series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100d, 95d, 100d, 80d, 85d, 70d).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(Math.log(80d / 100)), varCriterion.calculate(series, tradingRecord)); + assertNumEquals(numFactory.numOf(Math.log(80d / 100)), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateWithNoBarsShouldReturn0() { - series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100d, 95d, 100d, 80d, 85d, 70d).build(); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); + assertNumEquals(numFactory.numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithBuyAndHold() { - series = new MockBarSeries(numFunction, 100d, 99d); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100d, 99d).build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); - assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, position)); + assertNumEquals(numFactory.numOf(Math.log(99d / 100)), varCriterion.calculate(series, position)); } @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); - assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); - assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); + assertTrue(criterion.betterThan(numFactory.numOf(-0.1), numFactory.numOf(-0.2))); + assertFalse(criterion.betterThan(numFactory.numOf(-0.1), numFactory.numOf(0.0))); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterionTest.java index 2742c94f9..9efe27a67 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/VersusEnterAndHoldCriterionTest.java @@ -28,8 +28,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import static org.ta4j.core.num.NaN.NaN; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -37,19 +35,21 @@ import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.pnl.ReturnCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class VersusEnterAndHoldCriterionTest extends AbstractCriterionTest { - public VersusEnterAndHoldCriterionTest(Function numFunction) { - super(params -> new VersusEnterAndHoldCriterion((AnalysisCriterion) params[0]), numFunction); + public VersusEnterAndHoldCriterionTest(NumFactory numFactory) { + super(params -> new VersusEnterAndHoldCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateOnlyWithGainPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(new ReturnCriterion()); @@ -58,7 +58,7 @@ public void calculateOnlyWithGainPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -68,7 +68,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateWithOnlyOnePosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); Position position = new Position(Trade.buyAt(0, series), Trade.sellAt(1, series)); AnalysisCriterion buyAndHold = getCriterion(new ReturnCriterion()); @@ -77,7 +77,7 @@ public void calculateWithOnlyOnePosition() { @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); AnalysisCriterion buyAndHold = getCriterion(new ReturnCriterion()); assertNumEquals(1 / 0.7, buyAndHold.calculate(series, new BaseTradingRecord())); @@ -85,7 +85,7 @@ public void calculateWithNoPositions() { @Test public void calculateWithAverageProfit() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 130); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 130).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, NaN, NaN), Trade.sellAt(1, NaN, NaN), Trade.buyAt(2, NaN, NaN), Trade.sellAt(5, NaN, NaN)); @@ -97,7 +97,7 @@ public void calculateWithAverageProfit() { @Test public void calculateWithNumberOfBars() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 130); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 130).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/XLSCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/XLSCriterionTest.java index f76fecae2..e53286fa3 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/XLSCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/XLSCriterionTest.java @@ -23,13 +23,12 @@ */ package org.ta4j.core.criteria; -import java.util.function.Function; - import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalCriterionTest; import org.ta4j.core.TradingRecord; import org.ta4j.core.XlsTestsUtils; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class XLSCriterionTest implements ExternalCriterionTest { @@ -38,7 +37,7 @@ public class XLSCriterionTest implements ExternalCriterionTest { private final int criterionColumn; private final int statesColumn; private BarSeries cachedSeries = null; - private final Function numFunction; + private final NumFactory numFactory; /** * Constructor. @@ -50,12 +49,12 @@ public class XLSCriterionTest implements ExternalCriterionTest { * @param statesColumn column number containing the trading record states */ public XLSCriterionTest(Class clazz, String fileName, int criterionColumn, int statesColumn, - Function numFunction) { + NumFactory numFactory) { this.clazz = clazz; this.fileName = fileName; this.criterionColumn = criterionColumn; this.statesColumn = statesColumn; - this.numFunction = numFunction; + this.numFactory = numFactory; } /** @@ -68,7 +67,7 @@ public XLSCriterionTest(Class clazz, String fileName, int criterionColumn, in @Override public BarSeries getSeries() throws Exception { if (cachedSeries == null) { - cachedSeries = XlsTestsUtils.getSeries(clazz, fileName, numFunction); + cachedSeries = XlsTestsUtils.getSeries(clazz, fileName, numFactory); } return cachedSeries; } @@ -83,7 +82,7 @@ public BarSeries getSeries() throws Exception { */ @Override public Num getFinalCriterionValue(Object... params) throws Exception { - return XlsTestsUtils.getFinalCriterionValue(clazz, fileName, criterionColumn, getSeries().function(), params); + return XlsTestsUtils.getFinalCriterionValue(clazz, fileName, criterionColumn, getSeries().numFactory(), params); } /** @@ -93,7 +92,7 @@ public Num getFinalCriterionValue(Object... params) throws Exception { */ @Override public TradingRecord getTradingRecord() throws Exception { - return XlsTestsUtils.getTradingRecord(clazz, fileName, statesColumn, getSeries().function()); + return XlsTestsUtils.getTradingRecord(clazz, fileName, statesColumn, getSeries().numFactory()); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/AverageCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/AverageCriterionTest.java index 44e5e3359..f9b30bb6f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/AverageCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/AverageCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,22 +34,24 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; import org.ta4j.core.criteria.pnl.ProfitLossCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class AverageCriterionTest extends AbstractCriterionTest { - public AverageCriterionTest(Function numFunction) { + public AverageCriterionTest(NumFactory numFactory) { super(params -> params.length == 2 ? new AverageCriterion((AnalysisCriterion) params[0], (boolean) params[1]) - : new AverageCriterion((AnalysisCriterion) params[0]), numFunction); + : new AverageCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateStandardErrorPnL() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.one()), - Trade.sellAt(2, series, series.one()), Trade.buyAt(3, series, series.one()), - Trade.sellAt(5, series, series.one())); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().one()), + Trade.sellAt(2, series, series.numFactory().one()), Trade.buyAt(3, series, series.numFactory().one()), + Trade.sellAt(5, series, series.numFactory().one())); AnalysisCriterion criterion = getCriterion(new ProfitLossCriterion()); assertNumEquals(7.5, criterion.calculate(series, tradingRecord)); @@ -73,7 +73,7 @@ public void betterThanWithLessIsNotBetter() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(new ProfitLossCriterion()), 0); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterionTest.java index 0b330aa1a..cef345000 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/RelativeStandardDeviationCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,24 +34,26 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; import org.ta4j.core.criteria.pnl.ProfitLossCriterion; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; -import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class RelativeStandardDeviationCriterionTest extends AbstractCriterionTest { - public RelativeStandardDeviationCriterionTest(Function numFunction) { + public RelativeStandardDeviationCriterionTest(NumFactory numFactory) { super(params -> params.length == 2 ? new RelativeStandardDeviationCriterion((AnalysisCriterion) params[0], (boolean) params[1]) - : new RelativeStandardDeviationCriterion((AnalysisCriterion) params[0]), numFunction); + : new RelativeStandardDeviationCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateStandardDeviationPnL() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.one()), - Trade.sellAt(2, series, series.one()), Trade.buyAt(3, series, series.one()), - Trade.sellAt(5, series, series.one())); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().one()), + Trade.sellAt(2, series, series.numFactory().one()), Trade.buyAt(3, series, series.numFactory().one()), + Trade.sellAt(5, series, series.numFactory().one())); AnalysisCriterion criterion = getCriterion(new ProfitLossCriterion()); assertNumEquals(0.3333333333333333, criterion.calculate(series, tradingRecord)); @@ -75,7 +75,7 @@ public void betterThanWithLessIsNotBetter() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(new ProfitLossCriterion()), NaN.NaN); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterionTest.java index 90e1e72d6..c6ec7d3c7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardDeviationCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,23 +34,25 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; import org.ta4j.core.criteria.pnl.ProfitLossCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class StandardDeviationCriterionTest extends AbstractCriterionTest { - public StandardDeviationCriterionTest(Function numFunction) { + public StandardDeviationCriterionTest(NumFactory numFactory) { super(params -> params.length == 2 ? new StandardDeviationCriterion((AnalysisCriterion) params[0], (boolean) params[1]) - : new StandardDeviationCriterion((AnalysisCriterion) params[0]), numFunction); + : new StandardDeviationCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateStandardDeviationPnL() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.one()), - Trade.sellAt(2, series, series.one()), Trade.buyAt(3, series, series.one()), - Trade.sellAt(5, series, series.one())); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().one()), + Trade.sellAt(2, series, series.numFactory().one()), Trade.buyAt(3, series, series.numFactory().one()), + Trade.sellAt(5, series, series.numFactory().one())); AnalysisCriterion criterion = getCriterion(new ProfitLossCriterion()); assertNumEquals(2.5, criterion.calculate(series, tradingRecord)); @@ -74,7 +74,7 @@ public void betterThanWithLessIsNotBetter() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(new ProfitLossCriterion()), 0); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardErrorCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardErrorCriterionTest.java index 27703bdd8..3f4191251 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardErrorCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/StandardErrorCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,23 +34,25 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; import org.ta4j.core.criteria.pnl.ProfitLossCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class StandardErrorCriterionTest extends AbstractCriterionTest { - public StandardErrorCriterionTest(Function numFunction) { + public StandardErrorCriterionTest(NumFactory numFactory) { super(params -> params.length == 2 ? new StandardErrorCriterion((AnalysisCriterion) params[0], (boolean) params[1]) - : new StandardErrorCriterion((AnalysisCriterion) params[0]), numFunction); + : new StandardErrorCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateStandardErrorPnL() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.one()), - Trade.sellAt(2, series, series.one()), Trade.buyAt(3, series, series.one()), - Trade.sellAt(5, series, series.one())); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().one()), + Trade.sellAt(2, series, series.numFactory().one()), Trade.buyAt(3, series, series.numFactory().one()), + Trade.sellAt(5, series, series.numFactory().one())); AnalysisCriterion criterion = getCriterion(new ProfitLossCriterion()); assertNumEquals(1.7677669529663687, criterion.calculate(series, tradingRecord)); @@ -74,7 +74,7 @@ public void betterThanWithLessIsNotBetter() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(new ProfitLossCriterion()), 0); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/VarianceCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/VarianceCriterionTest.java index 334d994a0..3ca2b947d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/VarianceCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/helpers/VarianceCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,22 +34,24 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; import org.ta4j.core.criteria.pnl.ProfitLossCriterion; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class VarianceCriterionTest extends AbstractCriterionTest { - public VarianceCriterionTest(Function numFunction) { + public VarianceCriterionTest(NumFactory numFactory) { super(params -> params.length == 2 ? new VarianceCriterion((AnalysisCriterion) params[0], (boolean) params[1]) - : new VarianceCriterion((AnalysisCriterion) params[0]), numFunction); + : new VarianceCriterion((AnalysisCriterion) params[0]), numFactory); } @Test public void calculateVariancePnL() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.one()), - Trade.sellAt(2, series, series.one()), Trade.buyAt(3, series, series.one()), - Trade.sellAt(5, series, series.one())); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().one()), + Trade.sellAt(2, series, series.numFactory().one()), Trade.buyAt(3, series, series.numFactory().one()), + Trade.sellAt(5, series, series.numFactory().one())); AnalysisCriterion variance = getCriterion(new ProfitLossCriterion()); assertNumEquals(6.25, variance.calculate(series, tradingRecord)); @@ -73,7 +73,7 @@ public void betterThanWithLessIsNotBetter() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(new ProfitLossCriterion()), 0); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageLossCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageLossCriterionTest.java index c4311322c..097108d01 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageLossCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageLossCriterionTest.java @@ -27,63 +27,61 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; -import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class AverageLossCriterionTest extends AbstractCriterionTest { - public AverageLossCriterionTest(Function numFunction) { - super(params -> new AverageLossCriterion(), numFunction); + public AverageLossCriterionTest(NumFactory numFactory) { + super(params -> new AverageLossCriterion(), numFactory); } @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); - AnalysisCriterion avgLoss = getCriterion(); + var avgLoss = getCriterion(); assertNumEquals(0, avgLoss.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); + var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); - AnalysisCriterion avgLoss = getCriterion(); + var avgLoss = getCriterion(); assertNumEquals(-17.5, avgLoss.calculate(series, tradingRecord)); } @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 95, 100, 70, 80, 85, 100); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(95, 100, 70, 80, 85, 100).build(); + var tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); - AnalysisCriterion avgLoss = getCriterion(); + var avgLoss = getCriterion(); assertNumEquals(-17.5, avgLoss.calculate(series, tradingRecord)); } @Test public void betterThan() { - AnalysisCriterion criterion = getCriterion(); + var criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); } @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageProfitCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageProfitCriterionTest.java index ccd793549..dba55db3f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageProfitCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/AverageProfitCriterionTest.java @@ -27,26 +27,26 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class AverageProfitCriterionTest extends AbstractCriterionTest { - public AverageProfitCriterionTest(Function numFunction) { - super(params -> new AverageProfitCriterion(), numFunction); + public AverageProfitCriterionTest(NumFactory numFactory) { + super(params -> new AverageProfitCriterion(), numFactory); } @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -56,7 +56,7 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -66,7 +66,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 85, 80, 70, 100, 95); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 85, 80, 70, 100, 95).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -83,6 +83,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/LossCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/LossCriterionTest.java index b24bc43cb..0a56b28a1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/LossCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/LossCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -37,18 +35,18 @@ import org.ta4j.core.analysis.cost.LinearTransactionCostModel; import org.ta4j.core.analysis.cost.ZeroCostModel; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class LossCriterionTest extends AbstractCriterionTest { - public LossCriterionTest(Function numFunction) { - super(params -> new LossCriterion((boolean) params[0]), numFunction); + public LossCriterionTest(NumFactory numFactory) { + super(params -> new LossCriterion((boolean) params[0]), numFactory); } @Test public void calculateComparingIncludingVsExcludingCosts() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); LinearTransactionCostModel transactionCost = new LinearTransactionCostModel(0.01); ZeroCostModel holdingCost = new ZeroCostModel(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY, transactionCost, holdingCost); @@ -79,7 +77,9 @@ public void calculateComparingIncludingVsExcludingCosts() { @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -89,7 +89,7 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -99,7 +99,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 95, 100, 70, 80, 85, 100); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(95, 100, 70, 80, 85, 100).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -116,6 +116,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(true), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(true), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitCriterionTest.java index 4ca8002b6..4405501bf 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -37,18 +35,18 @@ import org.ta4j.core.analysis.cost.FixedTransactionCostModel; import org.ta4j.core.analysis.cost.ZeroCostModel; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ProfitCriterionTest extends AbstractCriterionTest { - public ProfitCriterionTest(Function numFunction) { - super(params -> new ProfitCriterion((boolean) params[0]), numFunction); + public ProfitCriterionTest(NumFactory numFactory) { + super(params -> new ProfitCriterion((boolean) params[0]), numFactory); } @Test public void calculateComparingIncludingVsExcludingCosts() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 100, 80, 85, 120); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 105, 100, 80, 85, 120).build(); FixedTransactionCostModel transactionCost = new FixedTransactionCostModel(1); ZeroCostModel holdingCost = new ZeroCostModel(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY, transactionCost, holdingCost); @@ -79,7 +77,9 @@ public void calculateComparingIncludingVsExcludingCosts() { @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -89,7 +89,7 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateOnlyWithProfitPositions2() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 100, 80, 85, 120); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 105, 100, 80, 85, 120).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -99,7 +99,7 @@ public void calculateOnlyWithProfitPositions2() { @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 95, 100, 70, 80, 85, 100); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(95, 100, 70, 80, 85, 100).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -116,6 +116,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(false), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(false), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossCriterionTest.java index dc41ff00f..7acd7056d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossCriterionTest.java @@ -27,29 +27,30 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ProfitLossCriterionTest extends AbstractCriterionTest { - public ProfitLossCriterionTest(Function numFunction) { - super(params -> new ProfitLossCriterion(), numFunction); + public ProfitLossCriterionTest(NumFactory numFactory) { + super(params -> new ProfitLossCriterion(), numFactory); } @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numOf(50)), - Trade.sellAt(2, series, series.numOf(50)), Trade.buyAt(3, series, series.numOf(50)), - Trade.sellAt(5, series, series.numOf(50))); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().numOf(50)), + Trade.sellAt(2, series, series.numFactory().numOf(50)), + Trade.buyAt(3, series, series.numFactory().numOf(50)), + Trade.sellAt(5, series, series.numFactory().numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(500 + 250, profit.calculate(series, tradingRecord)); @@ -57,10 +58,11 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numOf(50)), - Trade.sellAt(1, series, series.numOf(50)), Trade.buyAt(2, series, series.numOf(50)), - Trade.sellAt(5, series, series.numOf(50))); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series, series.numFactory().numOf(50)), + Trade.sellAt(1, series, series.numFactory().numOf(50)), + Trade.buyAt(2, series, series.numFactory().numOf(50)), + Trade.sellAt(5, series, series.numFactory().numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-250 - 1500, profit.calculate(series, tradingRecord)); @@ -68,10 +70,13 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateOnlyWithProfitShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series, series.numOf(50)), - Trade.buyAt(2, series, series.numOf(50)), Trade.sellAt(3, series, series.numOf(50)), - Trade.buyAt(5, series, series.numOf(50))); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series, series.numFactory().numOf(50)), + Trade.buyAt(2, series, series.numFactory().numOf(50)), + Trade.sellAt(3, series, series.numFactory().numOf(50)), + Trade.buyAt(5, series, series.numFactory().numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-(500 + 250), profit.calculate(series, tradingRecord)); @@ -79,10 +84,11 @@ public void calculateOnlyWithProfitShortPositions() { @Test public void calculateOnlyWithLossShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); - TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series, series.numOf(50)), - Trade.buyAt(1, series, series.numOf(50)), Trade.sellAt(2, series, series.numOf(50)), - Trade.buyAt(5, series, series.numOf(50))); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); + TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series, series.numFactory().numOf(50)), + Trade.buyAt(1, series, series.numFactory().numOf(50)), + Trade.sellAt(2, series, series.numFactory().numOf(50)), + Trade.buyAt(5, series, series.numFactory().numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(250 + 1500, profit.calculate(series, tradingRecord)); @@ -97,7 +103,7 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterionTest.java index f2db88676..5b0fe0bf9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossPercentageCriterionTest.java @@ -27,26 +27,26 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ProfitLossPercentageCriterionTest extends AbstractCriterionTest { - public ProfitLossPercentageCriterionTest(Function numFunction) { - super(params -> new ProfitLossPercentageCriterion(), numFunction); + public ProfitLossPercentageCriterionTest(NumFactory numFactory) { + super(params -> new ProfitLossPercentageCriterion(), numFactory); } @Test public void calculateWithWinningLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); @@ -55,7 +55,7 @@ public void calculateWithWinningLongPositions() { @Test public void calculateWithLosingLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -65,7 +65,7 @@ public void calculateWithLosingLongPositions() { @Test public void calculateWithOneWinningAndOneLosingLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 195, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 195, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -75,7 +75,7 @@ public void calculateWithOneWinningAndOneLosingLongPositions() { @Test public void calculateWithWinningShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 90, 100, 95, 95, 100); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 90, 100, 95, 95, 100).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(3, series)); AnalysisCriterion profit = getCriterion(); @@ -84,7 +84,9 @@ public void calculateWithWinningShortPositions() { @Test public void calculateWithLosingShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 110, 100, 105, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 100, 105, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(3, series)); AnalysisCriterion profit = getCriterion(); @@ -100,6 +102,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterionTest.java index 4382da86d..950ae0dad 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ProfitLossRatioCriterionTest.java @@ -27,26 +27,26 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ProfitLossRatioCriterionTest extends AbstractCriterionTest { - public ProfitLossRatioCriterionTest(Function numFunction) { - super(params -> new ProfitLossRatioCriterion(), numFunction); + public ProfitLossRatioCriterionTest(NumFactory numFactory) { + super(params -> new ProfitLossRatioCriterion(), numFactory); } @Test public void calculateOnlyWithProfitPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 120, 70, 100, 130, 105, 120); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(120, 70, 100, 130, 105, 120) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -56,7 +56,7 @@ public void calculateOnlyWithProfitPositions() { @Test public void calculateOnlyWithLossPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -66,7 +66,7 @@ public void calculateOnlyWithLossPositions() { @Test public void calculateProfitWithShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 85, 80, 70, 100, 95); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 85, 80, 70, 100, 95).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -83,6 +83,6 @@ public void betterThan() { @Test public void testCalculateOneOpenPositionShouldReturnZero() { - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 0); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ReturnCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ReturnCriterionTest.java index c329efa69..fa6557ec0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ReturnCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/pnl/ReturnCriterionTest.java @@ -27,8 +27,6 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BaseTradingRecord; @@ -36,19 +34,21 @@ import org.ta4j.core.Trade; import org.ta4j.core.TradingRecord; import org.ta4j.core.criteria.AbstractCriterionTest; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class ReturnCriterionTest extends AbstractCriterionTest { - public ReturnCriterionTest(Function numFunction) { + public ReturnCriterionTest(NumFactory numFunction) { super(params -> params.length == 1 ? new ReturnCriterion((boolean) params[0]) : new ReturnCriterion(), numFunction); } @Test public void calculateWithWinningLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 100, 95, 105) + .build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(2, series), Trade.buyAt(3, series), Trade.sellAt(5, series)); @@ -63,7 +63,7 @@ public void calculateWithWinningLongPositions() { @Test public void calculateWithLosingLongPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series), Trade.buyAt(2, series), Trade.sellAt(5, series)); @@ -78,7 +78,7 @@ public void calculateWithLosingLongPositions() { @Test public void calculateReturnWithWinningShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -93,7 +93,7 @@ public void calculateReturnWithWinningShortPositions() { @Test public void calculateReturnWithLosingShortPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 100, 80, 85, 130); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 105, 100, 80, 85, 130).build(); TradingRecord tradingRecord = new BaseTradingRecord(Trade.sellAt(0, series), Trade.buyAt(1, series), Trade.sellAt(2, series), Trade.buyAt(5, series)); @@ -108,7 +108,7 @@ public void calculateReturnWithLosingShortPositions() { @Test public void calculateWithNoPositions() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); // with base percentage should return 1 AnalysisCriterion retWithBase = getCriterion(); @@ -121,7 +121,7 @@ public void calculateWithNoPositions() { @Test public void calculateWithOpenedPosition() { - MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(100, 95, 100, 80, 85, 70).build(); // with base percentage should return 1 AnalysisCriterion retWithBase = getCriterion(); @@ -141,10 +141,10 @@ public void calculateWithOpenedPosition() { @Test public void testCalculateOneOpenPosition() { // with base percentage should return 1 - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(), 1); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(), 1); // without base percentage should return 0 - openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFunction, getCriterion(false), 0); + openedPositionUtils.testCalculateOneOpenPositionShouldReturnExpectedValue(numFactory, getCriterion(false), 0); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ATRIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ATRIndicatorTest.java index 9de5699c1..10ed99326 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ATRIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ATRIndicatorTest.java @@ -27,34 +27,77 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.Indicator; import org.ta4j.core.TestUtils; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ATRIndicatorTest extends AbstractIndicatorTest { private final ExternalIndicatorTest xls; - public ATRIndicatorTest(Function numFunction) throws Exception { - super((data, params) -> new ATRIndicator(data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "ATR.xls", 7, numFunction); + public ATRIndicatorTest(NumFactory numFactory) { + super((data, params) -> new ATRIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "ATR.xls", 7, numFactory); } @Test - public void testDummy() throws Exception { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); - series.addBar(new MockBar(ZonedDateTime.now().minusSeconds(5), 0, 12, 15, 8, 0, 0, 0, numFunction)); - series.addBar(new MockBar(ZonedDateTime.now().minusSeconds(4), 0, 8, 11, 6, 0, 0, 0, numFunction)); - series.addBar(new MockBar(ZonedDateTime.now().minusSeconds(3), 0, 15, 17, 14, 0, 0, 0, numFunction)); - series.addBar(new MockBar(ZonedDateTime.now().minusSeconds(2), 0, 15, 17, 14, 0, 0, 0, numFunction)); - series.addBar(new MockBar(ZonedDateTime.now().minusSeconds(1), 0, 0, 0, 2, 0, 0, 0, numFunction)); + public void testDummy() { + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.addBar(series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(5)) + .openPrice(0) + .closePrice(12) + .highPrice(15) + .lowPrice(8) + .amount(0) + .volume(0) + .build()); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(4)) + .openPrice(0) + .closePrice(8) + .highPrice(11) + .lowPrice(6) + .volume(0) + .amount(0) + .trades(0) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(3)) + .openPrice(0) + .closePrice(15) + .highPrice(17) + .lowPrice(14) + .volume(0) + .amount(0) + .trades(0) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(2)) + .openPrice(0) + .closePrice(15) + .highPrice(17) + .lowPrice(14) + .volume(0) + .amount(0) + .trades(0) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(1)) + .openPrice(0) + .closePrice(0) + .highPrice(0) + .lowPrice(2) + .volume(0) + .amount(0) + .trades(0) + .add(); Indicator indicator = getIndicator(series, 3); assertEquals(7d, indicator.getValue(0).doubleValue(), TestUtils.GENERAL_OFFSET); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java index 61127a1d3..31c3db4bb 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java @@ -26,17 +26,18 @@ import java.math.BigDecimal; import java.math.MathContext; import java.math.RoundingMode; -import java.util.Arrays; import java.util.List; -import java.util.function.Function; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.ta4j.core.Indicator; import org.ta4j.core.IndicatorFactory; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Abstract test class to extend BarSeries, Indicator an other test cases. The @@ -54,11 +55,11 @@ @RunWith(Parameterized.class) public abstract class AbstractIndicatorTest { - public final Function numFunction; + public final NumFactory numFactory; @Parameterized.Parameters(name = "Test Case: {index} (0=DoubleNum, 1=DecimalNum)") - public static List> function() { - return Arrays.asList(DoubleNum::valueOf, DecimalNum::valueOf); + public static List function() { + return List.of(new DoubleNumFactory(), new DecimalNumFactory()); } private final IndicatorFactory factory; @@ -66,24 +67,24 @@ public static List> function() { /** * Constructor. * - * @param factory IndicatorFactory for building an Indicator given data and - * parameters. - * @param numFunction the function to convert a Number into a Num implementation - * (automatically inserted by Junit) + * @param factory IndicatorFactory for building an Indicator given data and + * parameters. + * @param numFactory the factory to convert a Number into a Num implementation + * (automatically inserted by Junit) */ - public AbstractIndicatorTest(IndicatorFactory factory, Function numFunction) { - this.numFunction = numFunction; + public AbstractIndicatorTest(IndicatorFactory factory, NumFactory numFactory) { + this.numFactory = numFactory; this.factory = factory; } /** * Constructor * - * @param numFunction the function to convert a Number into a Num implementation - * (automatically inserted by Junit) + * @param numFactory the function to convert a Number into a Num implementation + * (automatically inserted by Junit) */ - public AbstractIndicatorTest(Function numFunction) { - this.numFunction = numFunction; + public AbstractIndicatorTest(NumFactory numFactory) { + this.numFactory = numFactory; this.factory = null; } @@ -100,11 +101,11 @@ public Indicator getIndicator(D data, Object... params) { } protected Num numOf(Number n) { - return numFunction.apply(n); + return numFactory.numOf(n); } public Num numOf(String string, int precision) { - MathContext mathContext = new MathContext(precision, RoundingMode.HALF_UP); + var mathContext = new MathContext(precision, RoundingMode.HALF_UP); return this.numOf(new BigDecimal(string, mathContext)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/AccelerationDecelerationIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/AccelerationDecelerationIndicatorTest.java index 3cf4c1185..e09140de5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/AccelerationDecelerationIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/AccelerationDecelerationIndicatorTest.java @@ -25,44 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AccelerationDecelerationIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public AccelerationDecelerationIndicatorTest(Function numFunction) { + public AccelerationDecelerationIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { + series = new MockBarSeriesBuilder().build(); - List bars = new ArrayList(); - - bars.add(new MockBar(0, 0, 16, 8, numFunction)); - bars.add(new MockBar(0, 0, 12, 6, numFunction)); - bars.add(new MockBar(0, 0, 18, 14, numFunction)); - bars.add(new MockBar(0, 0, 10, 6, numFunction)); - bars.add(new MockBar(0, 0, 8, 4, numFunction)); - - series = new MockBarSeries(bars); + series.barBuilder().openPrice(0).closePrice(0).highPrice(16).lowPrice(8).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(6).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(18).lowPrice(14).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(10).lowPrice(6).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(8).lowPrice(4).add(); } @Test public void calculateWithSma2AndSma3() { - AccelerationDecelerationIndicator acceleration = new AccelerationDecelerationIndicator(series, 2, 3); + var acceleration = new AccelerationDecelerationIndicator(series, 2, 3); assertNumEquals(0, acceleration.getValue(0)); assertNumEquals(0, acceleration.getValue(1)); @@ -73,7 +65,7 @@ public void calculateWithSma2AndSma3() { @Test public void withSma1AndSma2() { - AccelerationDecelerationIndicator acceleration = new AccelerationDecelerationIndicator(series, 1, 2); + var acceleration = new AccelerationDecelerationIndicator(series, 1, 2); assertNumEquals(0, acceleration.getValue(0)); assertNumEquals(0, acceleration.getValue(1)); @@ -84,7 +76,7 @@ public void withSma1AndSma2() { @Test public void withSmaDefault() { - AccelerationDecelerationIndicator acceleration = new AccelerationDecelerationIndicator(series); + var acceleration = new AccelerationDecelerationIndicator(series); assertNumEquals(0, acceleration.getValue(0)); assertNumEquals(0, acceleration.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/AwesomeOscillatorIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/AwesomeOscillatorIndicatorTest.java index 1f74eaea4..3f7b8ec19 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/AwesomeOscillatorIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/AwesomeOscillatorIndicatorTest.java @@ -25,49 +25,37 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.MedianPriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AwesomeOscillatorIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - /** - * Constructor. - * - * @param function - */ - public AwesomeOscillatorIndicatorTest(Function function) { - super(function); + public AwesomeOscillatorIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - - bars.add(new MockBar(0, 0, 16, 8, numFunction)); - bars.add(new MockBar(0, 0, 12, 6, numFunction)); - bars.add(new MockBar(0, 0, 18, 14, numFunction)); - bars.add(new MockBar(0, 0, 10, 6, numFunction)); - bars.add(new MockBar(0, 0, 8, 4, numFunction)); + this.series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(16).lowPrice(8).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(6).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(18).lowPrice(14).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(10).lowPrice(6).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(8).lowPrice(4).add(); - this.series = new MockBarSeries(bars); } @Test public void calculateWithSma2AndSma3() { - AwesomeOscillatorIndicator awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series), 2, 3); + var awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series), 2, 3); assertNumEquals(0, awesome.getValue(0)); assertNumEquals(0, awesome.getValue(1)); @@ -78,7 +66,7 @@ public void calculateWithSma2AndSma3() { @Test public void withSma1AndSma2() { - AwesomeOscillatorIndicator awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series), 1, 2); + var awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series), 1, 2); assertNumEquals(0, awesome.getValue(0)); assertNumEquals("-1.5", awesome.getValue(1)); @@ -89,7 +77,7 @@ public void withSma1AndSma2() { @Test public void withSmaDefault() { - AwesomeOscillatorIndicator awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series)); + var awesome = new AwesomeOscillatorIndicator(new MedianPriceIndicator(series)); assertNumEquals(0, awesome.getValue(0)); assertNumEquals(0, awesome.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/CCIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/CCIIndicatorTest.java index a235bf3b4..f15caee90 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/CCIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/CCIIndicatorTest.java @@ -25,16 +25,13 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; +import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CCIIndicatorTest extends AbstractIndicatorTest, Num> { @@ -42,29 +39,28 @@ public class CCIIndicatorTest extends AbstractIndicatorTest, Num> 23.91, 23.81, 23.92, 23.74, 24.68, 24.94, 24.93, 25.10, 25.12, 25.20, 25.06, 24.50, 24.31, 24.57, 24.62, 24.49, 24.37, 24.41, 24.35, 23.75, 24.09 }; - private MockBarSeries series; + private BarSeries series; /** * Constructor. * - * @param function + * @param numFactory */ - public CCIIndicatorTest(Function function) { - super(function); + public CCIIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - ArrayList bars = new ArrayList(); - for (Double price : typicalPrices) { - bars.add(new MockBar(price, price, price, price, numFunction)); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + for (var price : typicalPrices) { + series.barBuilder().openPrice(price).closePrice(price).highPrice(price).lowPrice(price).add(); } - series = new MockBarSeries(bars); } @Test public void getValueWhenBarCountIs20() { - CCIIndicator cci = new CCIIndicator(series, 20); + var cci = new CCIIndicator(series, 20); // Incomplete time frame assertNumEquals(0, cci.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/CMOIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/CMOIndicatorTest.java index ccf81fe77..47ba8e158 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/CMOIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/CMOIndicatorTest.java @@ -25,34 +25,35 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CMOIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public CMOIndicatorTest(Function numFunction) { - super(numFunction); + public CMOIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - series = new MockBarSeries(numFunction, 21.27, 22.19, 22.08, 22.47, 22.48, 22.53, 22.23, 21.43, 21.24, 21.29, - 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 24.75, 24.83, 23.95, 23.63, 23.82, 23.87, 23.15, 23.19, 23.10, - 22.65, 22.48, 22.87, 22.93, 22.91); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(21.27, 22.19, 22.08, 22.47, 22.48, 22.53, 22.23, 21.43, 21.24, 21.29, 22.15, 22.39, 22.38, + 22.61, 23.36, 24.05, 24.75, 24.83, 23.95, 23.63, 23.82, 23.87, 23.15, 23.19, 23.10, 22.65, + 22.48, 22.87, 22.93, 22.91) + .build(); } @Test public void dpo() { - CMOIndicator cmo = new CMOIndicator(new ClosePriceIndicator(series), 9); + var cmo = new CMOIndicator(new ClosePriceIndicator(series), 9); assertNumEquals(85.1351, cmo.getValue(5)); assertNumEquals(53.9326, cmo.getValue(6)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/CachedIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/CachedIndicatorTest.java index f195fc4be..36cfd243f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/CachedIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/CachedIndicatorTest.java @@ -31,7 +31,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.util.Arrays; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; @@ -42,8 +41,9 @@ import org.ta4j.core.Strategy; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.ConstantIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.OverIndicatorRule; import org.ta4j.core.rules.UnderIndicatorRule; @@ -51,18 +51,20 @@ public class CachedIndicatorTest extends AbstractIndicatorTest, N private BarSeries series; - public CachedIndicatorTest(Function numFunction) { - super(numFunction); + public CachedIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - series = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); } @Test public void ifCacheWorks() { - SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(series), 3); + var sma = new SMAIndicator(new ClosePriceIndicator(series), 3); Num firstTime = sma.getValue(4); Num secondTime = sma.getValue(4); assertEquals(firstTime, secondTime); @@ -72,14 +74,14 @@ public void ifCacheWorks() { public void getValueWithNullBarSeries() { ConstantIndicator constant = new ConstantIndicator<>( - new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(), numFunction.apply(10)); - assertEquals(numFunction.apply(10), constant.getValue(0)); - assertEquals(numFunction.apply(10), constant.getValue(100)); + new BaseBarSeriesBuilder().withNumFactory(numFactory).build(), numFactory.numOf(10)); + assertEquals(numFactory.numOf(10), constant.getValue(0)); + assertEquals(numFactory.numOf(10), constant.getValue(100)); assertNotNull(constant.getBarSeries()); SMAIndicator sma = new SMAIndicator(constant, 10); - assertEquals(numFunction.apply(10), sma.getValue(0)); - assertEquals(numFunction.apply(10), sma.getValue(100)); + assertEquals(numFactory.numOf(10), sma.getValue(0)); + assertEquals(numFactory.numOf(10), sma.getValue(100)); assertNotNull(sma.getBarSeries()); } @@ -87,7 +89,9 @@ public void getValueWithNullBarSeries() { public void getValueWithCacheLengthIncrease() { double[] data = new double[200]; Arrays.fill(data, 10); - SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(new MockBarSeries(numFunction, data)), 100); + SMAIndicator sma = new SMAIndicator( + new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory).withData(data).build()), + 100); assertNumEquals(10, sma.getValue(105)); } @@ -95,7 +99,7 @@ public void getValueWithCacheLengthIncrease() { public void getValueWithOldResultsRemoval() { double[] data = new double[20]; Arrays.fill(data, 1); - BarSeries barSeries = new MockBarSeries(numFunction, data); + BarSeries barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(data).build(); SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(barSeries), 10); assertNumEquals(1, sma.getValue(5)); assertNumEquals(1, sma.getValue(10)); @@ -105,14 +109,16 @@ public void getValueWithOldResultsRemoval() { @Test public void strategyExecutionOnCachedIndicatorAndLimitedBarSeries() { - BarSeries barSeries = new MockBarSeries(numFunction, 0, 1, 2, 3, 4, 5, 6, 7); + BarSeries barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(0, 1, 2, 3, 4, 5, 6, 7) + .build(); SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(barSeries), 2); // Theoretical values for SMA(2) cache: 0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5 barSeries.setMaximumBarCount(6); // Theoretical values for SMA(2) cache: null, null, 2, 2.5, 3.5, 4.5, 5.5, 6.5 - Strategy strategy = new BaseStrategy(new OverIndicatorRule(sma, sma.numOf(3)), - new UnderIndicatorRule(sma, sma.numOf(3))); + Strategy strategy = new BaseStrategy(new OverIndicatorRule(sma, numFactory.numOf(3)), + new UnderIndicatorRule(sma, numFactory.numOf(3))); // Theoretical shouldEnter results: false, false, false, false, true, true, // true, true // Theoretical shouldExit results: false, false, true, true, false, false, @@ -146,7 +152,7 @@ public void strategyExecutionOnCachedIndicatorAndLimitedBarSeries() { @Test public void getValueOnResultsCalculatedFromRemovedBarsShouldReturnFirstRemainingResult() { - BarSeries barSeries = new MockBarSeries(numFunction, 1, 1, 1, 1, 1); + BarSeries barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 1, 1, 1, 1).build(); barSeries.setMaximumBarCount(3); assertEquals(2, barSeries.getRemovedBarsCount()); @@ -160,7 +166,7 @@ public void getValueOnResultsCalculatedFromRemovedBarsShouldReturnFirstRemaining public void recursiveCachedIndicatorOnMovingBarSeriesShouldNotCauseStackOverflow() { // Added to check issue #120: https://github.com/mdeverdelhan/ta4j/issues/120 // See also: CachedIndicator#getValue(int index) - series = new MockBarSeries(numFunction); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); series.setMaximumBarCount(5); assertEquals(5, series.getBarCount()); @@ -174,8 +180,8 @@ public void recursiveCachedIndicatorOnMovingBarSeriesShouldNotCauseStackOverflow @Test public void leaveLastBarUncached() { - BarSeries barSeries = new MockBarSeries(numFunction); - SMAIndicator smaIndicator = new SMAIndicator(new ClosePriceIndicator(barSeries), 5); + BarSeries barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + var smaIndicator = new SMAIndicator(new ClosePriceIndicator(barSeries), 5); assertNumEquals(4998.0, smaIndicator.getValue(barSeries.getEndIndex())); barSeries.getLastBar().addTrade(numOf(10), numOf(5)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitLongIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitLongIndicatorTest.java index 68753c575..f28b240b2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitLongIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitLongIndicatorTest.java @@ -25,53 +25,46 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ChandelierExitLongIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public ChandelierExitLongIndicatorTest(Function numFunction) { - super(numFunction); + public ChandelierExitLongIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).add(); - data = new BaseBarSeries(bars); } @Test public void massIndexUsing3And8BarCounts() { - ChandelierExitLongIndicator cel = new ChandelierExitLongIndicator(data, 5, 2); + var cel = new ChandelierExitLongIndicator(data, 5, 2); assertNumEquals(44.9853, cel.getValue(5)); assertNumEquals(45.0162, cel.getValue(6)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitShortIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitShortIndicatorTest.java index 4812df637..7b3fe11ec 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitShortIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChandelierExitShortIndicatorTest.java @@ -25,53 +25,46 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ChandelierExitShortIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public ChandelierExitShortIndicatorTest(Function numFunction) { - super(numFunction); + public ChandelierExitShortIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).add(); - data = new BaseBarSeries(bars); } @Test public void massIndexUsing3And8BarCounts() { - ChandelierExitShortIndicator ces = new ChandelierExitShortIndicator(data, 5, 2); + var ces = new ChandelierExitShortIndicator(data, 5, 2); assertNumEquals(45.3246, ces.getValue(5)); assertNumEquals(45.3437, ces.getValue(6)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChopIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChopIndicatorTest.java index 4f5537941..ba7bd02c6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ChopIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ChopIndicatorTest.java @@ -28,14 +28,11 @@ import static org.junit.Assert.assertTrue; -import java.time.ZonedDateTime; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * @author jtomkinson @@ -43,11 +40,8 @@ */ public class ChopIndicatorTest extends AbstractIndicatorTest, Num> { - protected BarSeries series; - protected final BaseBarSeriesBuilder BarSeriesBuilder = new BaseBarSeriesBuilder().withNumTypeOf(numFunction); - - public ChopIndicatorTest(Function numFunction) { - super(numFunction); + public ChopIndicatorTest(NumFactory numFactory) { + super(numFactory); } /** @@ -55,12 +49,11 @@ public ChopIndicatorTest(Function numFunction) { */ @Test public void testChoppy() { - series = BarSeriesBuilder.withName("low volatility series").withNumTypeOf(numFunction).build(); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("low volatility series").build(); for (int i = 0; i < 50; i++) { - ZonedDateTime date = ZonedDateTime.now().minusSeconds(100000 - i); - series.addBar(date, 21.5, 21.5 + 1, 21.5 - 1, 21.5); + series.barBuilder().openPrice(21.5).highPrice(21.5 + 1).lowPrice(21.5 - 1).closePrice(21.5).add(); } - ChopIndicator ci1 = new ChopIndicator(series, 14, 100); + var ci1 = new ChopIndicator(series, 14, 100); int HIGH_CHOPPINESS_VALUE = 85; assertTrue(ci1.getValue(series.getEndIndex()).doubleValue() > HIGH_CHOPPINESS_VALUE); } @@ -71,11 +64,10 @@ public void testChoppy() { */ @Test public void testTradeableTrend() { - series = BarSeriesBuilder.withName("low volatility series").withNumTypeOf(numFunction).build(); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("low volatility series").build(); float value = 21.5f; for (int i = 0; i < 50; i++) { - ZonedDateTime date = ZonedDateTime.now().minusSeconds(100000 - i); - series.addBar(date, value, value + 1, value - 1, value); + series.barBuilder().openPrice(value).highPrice(value + 1).lowPrice(value - 1).closePrice(value).add(); value += 2.0f; } ChopIndicator ci1 = new ChopIndicator(series, 14, 100); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/CoppockCurveIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/CoppockCurveIndicatorTest.java index 41f0b2dbc..49260808e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/CoppockCurveIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/CoppockCurveIndicatorTest.java @@ -25,31 +25,31 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CoppockCurveIndicatorTest extends AbstractIndicatorTest, Num> { - public CoppockCurveIndicatorTest(Function numFunction) { - super(numFunction); + public CoppockCurveIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void coppockCurveWithRoc14Roc11Wma10() { // Example from // http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:coppock_curve - BarSeries data = new MockBarSeries(numFunction, 872.81, 919.14, 919.32, 987.48, 1020.62, 1057.08, 1036.19, - 1095.63, 1115.1, 1073.87, 1104.49, 1169.43, 1186.69, 1089.41, 1030.71, 1101.6, 1049.33, 1141.2, 1183.26, - 1180.55, 1257.64, 1286.12, 1327.22, 1325.83, 1363.61, 1345.2, 1320.64, 1292.28, 1218.89, 1131.42, - 1253.3, 1246.96, 1257.6, 1312.41, 1365.68, 1408.47, 1397.91, 1310.33, 1362.16, 1379.32); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(872.81, 919.14, 919.32, 987.48, 1020.62, 1057.08, 1036.19, 1095.63, 1115.1, 1073.87, 1104.49, + 1169.43, 1186.69, 1089.41, 1030.71, 1101.6, 1049.33, 1141.2, 1183.26, 1180.55, 1257.64, 1286.12, + 1327.22, 1325.83, 1363.61, 1345.2, 1320.64, 1292.28, 1218.89, 1131.42, 1253.3, 1246.96, 1257.6, + 1312.41, 1365.68, 1408.47, 1397.91, 1310.33, 1362.16, 1379.32) + .build(); - CoppockCurveIndicator cc = new CoppockCurveIndicator(new ClosePriceIndicator(data), 14, 11, 10); + var cc = new CoppockCurveIndicator(new ClosePriceIndicator(data), 14, 11, 10); assertNumEquals(23.8929, cc.getValue(31)); assertNumEquals(19.3187, cc.getValue(32)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/DPOIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/DPOIndicatorTest.java index 141b44cb2..c775e8ada 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/DPOIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/DPOIndicatorTest.java @@ -26,41 +26,42 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DPOIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public DPOIndicatorTest(Function numFunction) { - super(numFunction); + public DPOIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - series = new MockBarSeries(numFunction, 22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29, - 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, - 23.33, 22.68, 23.10, 22.40, 22.17, 22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29, - 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, - 23.33, 22.68, 23.10, 22.40, 22.17, 22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29, - 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, - 23.33, 22.68, 23.10, 22.40, 22.17); + series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29, 22.15, 22.39, 22.38, + 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, 23.33, + 22.68, 23.10, 22.40, 22.17, 22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, + 22.29, 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, + 23.65, 23.19, 23.10, 23.33, 22.68, 23.10, 22.40, 22.17, 22.27, 22.19, 22.08, 22.17, 22.18, + 22.13, 22.23, 22.43, 22.24, 22.29, 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, + 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, 23.33, 22.68, 23.10, 22.40, 22.17) + .build(); } @Test public void dpo() { - DPOIndicator dpo = new DPOIndicator(series, 9); - ClosePriceIndicator cp = new ClosePriceIndicator(series); - SMAIndicator sma = new SMAIndicator(cp, 9); + var dpo = new DPOIndicator(series, 9); + var cp = new ClosePriceIndicator(series); + var sma = new SMAIndicator(cp, 9); int timeShift = 9 / 2 + 1; // compare results to alternative calculation for each index diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/DistanceFromMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/DistanceFromMAIndicatorTest.java index b2379043f..692ab8137 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/DistanceFromMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/DistanceFromMAIndicatorTest.java @@ -25,26 +25,27 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DistanceFromMAIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public DistanceFromMAIndicatorTest(Function numFunction) { - super(numFunction); + public DistanceFromMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 10, 15, 20, 18, 17, 18, 15, 12, 10, 8, 5, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(10, 15, 20, 18, 17, 18, 15, 12, 10, 8, 5, 2) + .build(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/DoubleEMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/DoubleEMAIndicatorTest.java index 67291c111..77364361f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/DoubleEMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/DoubleEMAIndicatorTest.java @@ -25,34 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DoubleEMAIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePrice; - public DoubleEMAIndicatorTest(Function numFunction) { - super(numFunction); + public DoubleEMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 0.73, 0.72, 0.86, 0.72, 0.62, 0.76, 0.84, 0.69, 0.65, 0.71, - 0.53, 0.73, 0.77, 0.67, 0.68); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(0.73, 0.72, 0.86, 0.72, 0.62, 0.76, 0.84, 0.69, 0.65, 0.71, 0.53, 0.73, 0.77, 0.67, 0.68) + .build(); closePrice = new ClosePriceIndicator(data); } @Test public void doubleEMAUsingBarCount5UsingClosePrice() { - DoubleEMAIndicator doubleEma = new DoubleEMAIndicator(closePrice, 5); + var doubleEma = new DoubleEMAIndicator(closePrice, 5); assertNumEquals(0.73, doubleEma.getValue(0)); assertNumEquals(0.7244, doubleEma.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/EMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/EMAIndicatorTest.java index 6414df958..de1a5aade 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/EMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/EMAIndicatorTest.java @@ -27,47 +27,43 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.Indicator; import org.ta4j.core.TestUtils; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class EMAIndicatorTest extends AbstractIndicatorTest, Num> { private final ExternalIndicatorTest xls; - public EMAIndicatorTest(Function numFunction) throws Exception { - super((data, params) -> new EMAIndicator(data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "EMA.xls", 6, numFunction); + public EMAIndicatorTest(NumFactory numFactory) { + super((data, params) -> new EMAIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "EMA.xls", 6, numFactory); } private BarSeries data; @Before public void setUp() { - data = new MockBarSeries(numFunction, 64.75, 63.79, 63.73, 63.73, 63.55, 63.19, 63.91, 63.85, 62.95, 63.37, - 61.33, 61.51); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(64.75, 63.79, 63.73, 63.73, 63.55, 63.19, 63.91, 63.85, 62.95, 63.37, 61.33, 61.51) + .build(); } @Test - public void firstValueShouldBeEqualsToFirstDataValue() throws Exception { + public void firstValueShouldBeEqualsToFirstDataValue() { Indicator indicator = getIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(64.75, indicator.getValue(0)); } @Test - public void usingBarCount10UsingClosePrice() throws Exception { + public void usingBarCount10UsingClosePrice() { Indicator indicator = getIndicator(new ClosePriceIndicator(data), 10); assertNumEquals(63.6948, indicator.getValue(9)); assertNumEquals(63.2648, indicator.getValue(10)); @@ -76,11 +72,10 @@ public void usingBarCount10UsingClosePrice() throws Exception { @Test public void stackOverflowError() throws Exception { - List bigListOfBars = new ArrayList(); + var bigSeries = new MockBarSeriesBuilder().build(); for (int i = 0; i < 10000; i++) { - bigListOfBars.add(new MockBar(i, numFunction)); + bigSeries.barBuilder().closePrice(i).add(); } - MockBarSeries bigSeries = new MockBarSeries(bigListOfBars); Indicator indicator = getIndicator(new ClosePriceIndicator(bigSeries), 10); // if a StackOverflowError is thrown here, then the RecursiveCachedIndicator // does not work as intended. diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/FisherIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/FisherIndicatorTest.java index 24d38a168..2e8a6c365 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/FisherIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/FisherIndicatorTest.java @@ -26,75 +26,173 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class FisherIndicatorTest extends AbstractIndicatorTest, Num> { protected BarSeries series; - public FisherIndicatorTest(Function numFunction) { - super(null, numFunction); + public FisherIndicatorTest(NumFactory numFactory) { + super(null, numFactory); } @Before public void setUp() { - series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("NaN test").build(); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("NaN test").build(); int i = 20; - // open, close, max, min - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 44.98, 45.05, 45.17, 44.96, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.05, 45.10, 45.15, 44.99, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.11, 45.19, 45.32, 45.11, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.19, 45.14, 45.25, 45.04, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.12, 45.15, 45.20, 45.10, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.15, 45.14, 45.20, 45.10, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.13, 45.10, 45.16, 45.07, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.12, 45.15, 45.22, 45.10, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.15, 45.22, 45.27, 45.14, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.24, 45.43, 45.45, 45.20, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.43, 45.44, 45.50, 45.39, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.43, 45.55, 45.60, 45.35, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.58, 45.55, 45.61, 45.39, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.45, 45.01, 45.55, 44.80, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 45.03, 44.23, 45.04, 44.17, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 44.23, 43.95, 44.29, 43.81, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 43.91, 43.08, 43.99, 43.08, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 43.07, 43.55, 43.65, 43.06, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i--), 43.56, 43.95, 43.99, 43.53, 0, 1, 0, numFunction)); - series.addBar( - new MockBar(ZonedDateTime.now().minusSeconds(i), 43.93, 44.47, 44.58, 43.93, 0, 1, 0, numFunction)); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(44.98) + .closePrice(45.05) + .highPrice(45.17) + .lowPrice(44.96) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.05) + .closePrice(45.10) + .highPrice(45.15) + .lowPrice(44.99) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.11) + .closePrice(45.19) + .highPrice(45.32) + .lowPrice(45.11) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.19) + .closePrice(45.14) + .highPrice(45.25) + .lowPrice(45.04) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.12) + .closePrice(45.15) + .highPrice(45.20) + .lowPrice(45.10) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.15) + .closePrice(45.14) + .highPrice(45.20) + .lowPrice(45.10) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.13) + .closePrice(45.10) + .highPrice(45.16) + .lowPrice(45.07) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.12) + .closePrice(45.15) + .highPrice(45.22) + .lowPrice(45.10) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.15) + .closePrice(45.22) + .highPrice(45.27) + .lowPrice(45.14) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.24) + .closePrice(45.43) + .highPrice(45.45) + .lowPrice(45.20) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.43) + .closePrice(45.44) + .highPrice(45.50) + .lowPrice(45.39) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.43) + .closePrice(45.55) + .highPrice(45.60) + .lowPrice(45.35) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.58) + .closePrice(45.55) + .highPrice(45.61) + .lowPrice(45.39) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.45) + .closePrice(45.01) + .highPrice(45.55) + .lowPrice(44.80) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(45.03) + .closePrice(44.23) + .highPrice(45.04) + .lowPrice(44.17) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(44.23) + .closePrice(43.95) + .highPrice(44.29) + .lowPrice(43.81) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(43.91) + .closePrice(43.08) + .highPrice(43.99) + .lowPrice(43.08) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(43.07) + .closePrice(43.55) + .highPrice(43.65) + .lowPrice(43.06) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i--)) + .openPrice(43.56) + .closePrice(43.95) + .highPrice(43.99) + .lowPrice(43.53) + .add(); + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds(i)) + .openPrice(43.93) + .closePrice(44.47) + .highPrice(44.58) + .lowPrice(43.93) + .add(); } @Test public void fisher() { - FisherIndicator fisher = new FisherIndicator(series); + var fisher = new FisherIndicator(series); assertNumEquals(0.6448642008177138, fisher.getValue(10)); assertNumEquals(0.8361770425706673, fisher.getValue(11)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/HMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/HMAIndicatorTest.java index 71d45d10c..0668eefdf 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/HMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/HMAIndicatorTest.java @@ -25,35 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class HMAIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public HMAIndicatorTest(Function numFunction) { + public HMAIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 84.53, 87.39, 84.55, 82.83, 82.58, 83.74, 83.33, 84.57, 86.98, 87.10, - 83.11, 83.60, 83.66, 82.76, 79.22, 79.03, 78.18, 77.42, 74.65, 77.48, 76.87); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(84.53, 87.39, 84.55, 82.83, 82.58, 83.74, 83.33, 84.57, 86.98, 87.10, 83.11, 83.60, 83.66, + 82.76, 79.22, 79.03, 78.18, 77.42, 74.65, 77.48, 76.87) + .build(); } @Test public void hmaUsingBarCount9UsingClosePrice() { // Example from // http://traders.com/Documentation/FEEDbk_docs/2010/12/TradingIndexesWithHullMA.xls - HMAIndicator hma = new HMAIndicator(new ClosePriceIndicator(data), 9); + var hma = new HMAIndicator(new ClosePriceIndicator(data), 9); assertNumEquals(86.3204, hma.getValue(10)); assertNumEquals(85.3705, hma.getValue(11)); assertNumEquals(84.1044, hma.getValue(12)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicatorTest.java index e77b023e6..409d6173a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/IntraDayMomentumIndexIndicatorTest.java @@ -23,48 +23,43 @@ */ package org.ta4j.core.indicators; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.ta4j.core.TestUtils.assertNumEquals; + import org.junit.Before; import org.junit.Test; -import org.ta4j.core.*; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.BarSeries; +import org.ta4j.core.Indicator; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; - -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - -import static org.junit.Assert.*; -import static org.ta4j.core.TestUtils.assertNumEquals; +import org.ta4j.core.num.NumFactory; public class IntraDayMomentumIndexIndicatorTest extends AbstractIndicatorTest, Num> { - private List mockBarList; private BarSeries mockBarSeries; - public IntraDayMomentumIndexIndicatorTest(Function numFunction) { - super(numFunction); + public IntraDayMomentumIndexIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - mockBarList = new ArrayList<>(); - mockBarList.add(new MockBar(10, 9, 10, 9, numFunction)); - mockBarList.add(new MockBar(10, 11, 11, 10, 10, numFunction)); - mockBarList.add(new MockBar(11, 12, 12, 10, 10, numFunction)); - mockBarList.add(new MockBar(10, 12, 12, 10, 10, numFunction)); - mockBarList.add(new MockBar(9, 12, 12, 9, 10, numFunction)); - mockBarList.add(new MockBar(9, 8, 9, 8, 10, numFunction)); - mockBarList.add(new MockBar(11, 8, 11, 8, 10, numFunction)); - mockBarList.add(new MockBar(10, 13, 13, 9, 10, numFunction)); - mockBarList.add(new MockBar(11, 2, 11, 2, 10, numFunction)); - - mockBarSeries = new MockBarSeries(mockBarList); - } + mockBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + mockBarSeries.barBuilder().openPrice(10).closePrice(9).highPrice(10).lowPrice(9).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(11).highPrice(11).lowPrice(10).volume(10).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).volume(10).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(12).highPrice(12).lowPrice(10).volume(10).add(); + mockBarSeries.barBuilder().openPrice(9).closePrice(12).highPrice(12).lowPrice(9).volume(10).add(); + mockBarSeries.barBuilder().openPrice(9).closePrice(8).highPrice(9).lowPrice(8).volume(10).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(8).highPrice(11).lowPrice(8).volume(10).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(13).highPrice(13).lowPrice(9).volume(10).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(2).highPrice(11).lowPrice(2).volume(10).add(); + }; @Test public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { - IntraDayMomentumIndexIndicator imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 5); + var imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 5); assertTrue(imi.getValue(0).isNaN()); assertTrue(imi.getValue(1).isNaN()); @@ -76,7 +71,7 @@ public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { @Test public void givenBarCountOf1_whenGetValue_thenReturnCorrectValue() { - IntraDayMomentumIndexIndicator imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 1); + var imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 1); assertTrue(imi.getValue(0).isNaN()); assertNumEquals(100, imi.getValue(1)); @@ -89,7 +84,7 @@ public void givenBarCountOf1_whenGetValue_thenReturnCorrectValue() { @Test public void givenBarCountOf3_whenGetValue_thenReturnCorrectValue() { - IntraDayMomentumIndexIndicator imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 3); + var imi = new IntraDayMomentumIndexIndicator(mockBarSeries, 3); assertTrue(imi.getValue(0).isNaN()); assertTrue(imi.getValue(1).isNaN()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/KAMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/KAMAIndicatorTest.java index 66bb20f94..23f7ebbdd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/KAMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/KAMAIndicatorTest.java @@ -27,15 +27,14 @@ import static org.junit.Assert.fail; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * The Class KAMAIndicatorTest. @@ -48,26 +47,26 @@ public class KAMAIndicatorTest extends AbstractIndicatorTest, Num private BarSeries data; - public KAMAIndicatorTest(Function numFunction) { - super(numFunction); + public KAMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 110.46, 109.80, 110.17, 109.82, 110.15, 109.31, 109.05, 107.94, 107.76, - 109.24, 109.40, 108.50, 107.96, 108.55, 108.85, 110.44, 109.89, 110.70, 110.79, 110.22, 110.00, 109.27, - 106.69, 107.07, 107.92, 107.95, 107.70, 107.97, 106.09, 106.03, 107.65, 109.54, 110.26, 110.38, 111.94, - 113.59, 113.98, 113.91, 112.62, 112.20, 111.10, 110.18, 111.13, 111.55, 112.08, 111.95, 111.60, 111.39, - 112.25 - - ); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(110.46, 109.80, 110.17, 109.82, 110.15, 109.31, 109.05, 107.94, 107.76, 109.24, 109.40, + 108.50, 107.96, 108.55, 108.85, 110.44, 109.89, 110.70, 110.79, 110.22, 110.00, 109.27, 106.69, + 107.07, 107.92, 107.95, 107.70, 107.97, 106.09, 106.03, 107.65, 109.54, 110.26, 110.38, 111.94, + 113.59, 113.98, 113.91, 112.62, 112.20, 111.10, 110.18, 111.13, 111.55, 112.08, 111.95, 111.60, + 111.39, 112.25) + .build(); } @Test public void kama() { - ClosePriceIndicator closePrice = new ClosePriceIndicator(data); - KAMAIndicator kama = new KAMAIndicator(closePrice, 10, 2, 30); + var closePrice = new ClosePriceIndicator(data); + var kama = new KAMAIndicator(closePrice, 10, 2, 30); assertNumEquals(109.2400, kama.getValue(9)); assertNumEquals(109.2449, kama.getValue(10)); @@ -113,11 +112,11 @@ public void kama() { @Test public void getValueOnDeepIndicesShouldNotCauseStackOverflow() { - BarSeries series = new MockBarSeries(numFunction); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); series.setMaximumBarCount(5000); assertEquals(5000, series.getBarCount()); - KAMAIndicator kama = new KAMAIndicator(new ClosePriceIndicator(series), 10, 2, 30); + var kama = new KAMAIndicator(new ClosePriceIndicator(series), 10, 2, 30); try { assertNumEquals("2999.75", kama.getValue(3000)); } catch (Throwable t) { diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/KSTIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/KSTIndicatorTest.java index 4127178a9..8aef2144a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/KSTIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/KSTIndicatorTest.java @@ -25,36 +25,38 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; +import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class KSTIndicatorTest extends AbstractIndicatorTest, Num> { - private MockBarSeries data; + private BarSeries data; - public KSTIndicatorTest(Function numFunction) { - super(numFunction); + public KSTIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1344.78, 1357.98, 1355.69, 1325.51, 1335.02, 1313.72, 1319.99, 1331.85, - 1329.04, 1362.16, 1365.51, 1374.02, 1367.58, 1354.68, 1352.46, 1341.47, 1341.45, 1334.76, 1356.78, - 1353.64, 1363.67, 1372.78, 1376.51, 1362.66, 1350.52, 1338.31, 1337.89, 1360.02, 1385.97, 1385.30, - 1379.32, 1375.32, 1365.00, 1390.99, 1394.23, 1401.35, 1402.22, 1402.80, 1405.87, 1404.11, 1403.93, - 1405.53, 1415.51, 1418.16, 1418.13, 1413.17, 1413.49, 1402.08, 1411.13, 1410.44); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1344.78, 1357.98, 1355.69, 1325.51, 1335.02, 1313.72, 1319.99, 1331.85, 1329.04, 1362.16, + 1365.51, 1374.02, 1367.58, 1354.68, 1352.46, 1341.47, 1341.45, 1334.76, 1356.78, 1353.64, + 1363.67, 1372.78, 1376.51, 1362.66, 1350.52, 1338.31, 1337.89, 1360.02, 1385.97, 1385.30, + 1379.32, 1375.32, 1365.00, 1390.99, 1394.23, 1401.35, 1402.22, 1402.80, 1405.87, 1404.11, + 1403.93, 1405.53, 1415.51, 1418.16, 1418.13, 1413.17, 1413.49, 1402.08, 1411.13, 1410.44) + .build(); } @Test public void KSTIndicator() { - ClosePriceIndicator closePriceIndicator = new ClosePriceIndicator(data); - KSTIndicator kstIndicator = new KSTIndicator(closePriceIndicator); + var closePriceIndicator = new ClosePriceIndicator(data); + var kstIndicator = new KSTIndicator(closePriceIndicator); assertNumEquals(36.597637, kstIndicator.getValue(44)); assertNumEquals(37.228478, kstIndicator.getValue(45)); assertNumEquals(38.381911, kstIndicator.getValue(46)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/LWMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/LWMAIndicatorTest.java index 8b874bc7f..7b07ff7c9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/LWMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/LWMAIndicatorTest.java @@ -25,33 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LWMAIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public LWMAIndicatorTest(Function numFunction) { + public LWMAIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 37.08, 36.7, 36.11, 35.85, 35.71, 36.04, 36.41, 37.67, 38.01, 37.79, - 36.83); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(37.08, 36.7, 36.11, 35.85, 35.71, 36.04, 36.41, 37.67, 38.01, 37.79, 36.83) + .build(); } @Test public void lwmaUsingBarCount5UsingClosePrice() { - LWMAIndicator lwma = new LWMAIndicator(new ClosePriceIndicator(data), 5); + var lwma = new LWMAIndicator(new ClosePriceIndicator(data), 5); assertNumEquals(0.0, lwma.getValue(0)); assertNumEquals(0.0, lwma.getValue(1)); assertNumEquals(0.0, lwma.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/MACDIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/MACDIndicatorTest.java index 407606c06..0a81017d7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/MACDIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/MACDIndicatorTest.java @@ -25,28 +25,29 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MACDIndicatorTest extends AbstractIndicatorTest, Num> { - public MACDIndicatorTest(Function numFunction) { - super(numFunction); + public MACDIndicatorTest(NumFactory numFactory) { + super(numFactory); } private BarSeries data; @Before public void setUp() { - data = new MockBarSeries(numFunction, 37.08, 36.7, 36.11, 35.85, 35.71, 36.04, 36.41, 37.67, 38.01, 37.79, - 36.83, 37.10, 38.01, 38.50, 38.99); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(37.08, 36.7, 36.11, 35.85, 35.71, 36.04, 36.41, 37.67, 38.01, 37.79, 36.83, 37.10, 38.01, + 38.50, 38.99) + .build(); } @Test(expected = IllegalArgumentException.class) @@ -56,7 +57,7 @@ public void throwsErrorOnIllegalArguments() { @Test public void macdUsingPeriod5And10() { - MACDIndicator macdIndicator = new MACDIndicator(new ClosePriceIndicator(data), 5, 10); + var macdIndicator = new MACDIndicator(new ClosePriceIndicator(data), 5, 10); assertNumEquals(0.0, macdIndicator.getValue(0)); assertNumEquals(-0.05757, macdIndicator.getValue(1)); assertNumEquals(-0.17488, macdIndicator.getValue(2)); @@ -75,4 +76,4 @@ public void macdUsingPeriod5And10() { assertNumEquals(37.0118, macdIndicator.getLongTermEma().getValue(10)); assertNumEquals(37.1807, macdIndicator.getShortTermEma().getValue(10)); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/MMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/MMAIndicatorTest.java index d075e485e..2b6130e54 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/MMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/MMAIndicatorTest.java @@ -26,27 +26,22 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.Indicator; import org.ta4j.core.TestUtils; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MMAIndicatorTest extends AbstractIndicatorTest, Num> { private final ExternalIndicatorTest xls; - public MMAIndicatorTest(Function numFunction) throws Exception { + public MMAIndicatorTest(NumFactory numFunction) { super((data, params) -> new MMAIndicator(data, (int) params[0]), numFunction); xls = new XLSIndicatorTest(this.getClass(), "MMA.xls", 6, numFunction); } @@ -55,33 +50,33 @@ public MMAIndicatorTest(Function numFunction) throws Exception { @Before public void setUp() { - data = new MockBarSeries(numFunction, 64.75, 63.79, 63.73, 63.73, 63.55, 63.19, 63.91, 63.85, 62.95, 63.37, - 61.33, 61.51); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(64.75, 63.79, 63.73, 63.73, 63.55, 63.19, 63.91, 63.85, 62.95, 63.37, 61.33, 61.51) + .build(); } @Test - public void firstValueShouldBeEqualsToFirstDataValue() throws Exception { - Indicator actualIndicator = getIndicator(new ClosePriceIndicator(data), 1); + public void firstValueShouldBeEqualsToFirstDataValue() { + var actualIndicator = getIndicator(new ClosePriceIndicator(data), 1); assertEquals(64.75, actualIndicator.getValue(0).doubleValue(), TestUtils.GENERAL_OFFSET); } @Test - public void mmaUsingBarCount10UsingClosePrice() throws Exception { - Indicator actualIndicator = getIndicator(new ClosePriceIndicator(data), 10); + public void mmaUsingBarCount10UsingClosePrice() { + var actualIndicator = getIndicator(new ClosePriceIndicator(data), 10); assertEquals(63.9983, actualIndicator.getValue(9).doubleValue(), TestUtils.GENERAL_OFFSET); assertEquals(63.7315, actualIndicator.getValue(10).doubleValue(), TestUtils.GENERAL_OFFSET); assertEquals(63.5093, actualIndicator.getValue(11).doubleValue(), TestUtils.GENERAL_OFFSET); } @Test - public void stackOverflowError() throws Exception { - List bigListOfBars = new ArrayList<>(); + public void stackOverflowError() { + var bigSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); for (int i = 0; i < 10000; i++) { - bigListOfBars.add(new MockBar(i, numFunction)); + bigSeries.barBuilder().closePrice(i).add(); } - MockBarSeries bigSeries = new MockBarSeries(bigListOfBars); - ClosePriceIndicator closePrice = new ClosePriceIndicator(bigSeries); - Indicator actualIndicator = getIndicator(closePrice, 10); + var closePrice = new ClosePriceIndicator(bigSeries); + var actualIndicator = getIndicator(closePrice, 10); // if a StackOverflowError is thrown here, then the RecursiveCachedIndicator // does not work as intended. assertEquals(9990.0, actualIndicator.getValue(9999).doubleValue(), TestUtils.GENERAL_OFFSET); @@ -89,7 +84,7 @@ public void stackOverflowError() throws Exception { @Test public void testAgainstExternalData() throws Exception { - Indicator xlsClose = new ClosePriceIndicator(xls.getSeries()); + var xlsClose = new ClosePriceIndicator(xls.getSeries()); Indicator actualIndicator; actualIndicator = getIndicator(xlsClose, 1); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/MassIndexIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/MassIndexIndicatorTest.java index 1b9878c06..b732b4022 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/MassIndexIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/MassIndexIndicatorTest.java @@ -25,58 +25,51 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MassIndexIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public MassIndexIndicatorTest(Function function) { - super(function); + public MassIndexIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, numFunction)); - bars.add(new MockBar(44.23, 43.95, 44.29, 43.81, numFunction)); - bars.add(new MockBar(43.91, 43.08, 43.99, 43.08, numFunction)); - bars.add(new MockBar(43.07, 43.55, 43.65, 43.06, numFunction)); - bars.add(new MockBar(43.56, 43.95, 43.99, 43.53, numFunction)); - bars.add(new MockBar(43.93, 44.47, 44.58, 43.93, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).add(); + data.barBuilder().openPrice(44.23).closePrice(43.95).highPrice(44.29).lowPrice(43.81).add(); + data.barBuilder().openPrice(43.91).closePrice(43.08).highPrice(43.99).lowPrice(43.08).add(); + data.barBuilder().openPrice(43.07).closePrice(43.55).highPrice(43.65).lowPrice(43.06).add(); + data.barBuilder().openPrice(43.56).closePrice(43.95).highPrice(43.99).lowPrice(43.53).add(); + data.barBuilder().openPrice(43.93).closePrice(44.47).highPrice(44.58).lowPrice(43.93).add(); - data = new BaseBarSeries(bars); } @Test public void massIndexUsing3And8BarCounts() { - MassIndexIndicator massIndex = new MassIndexIndicator(data, 3, 8); + var massIndex = new MassIndexIndicator(data, 3, 8); assertNumEquals(1, massIndex.getValue(0)); assertNumEquals(9.1158, massIndex.getValue(14)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/PPOIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/PPOIndicatorTest.java index 7b0a9bf63..d31c4c929 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/PPOIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/PPOIndicatorTest.java @@ -25,35 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PPOIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePriceIndicator; - public PPOIndicatorTest(Function numFunction) { - super(numFunction); + public PPOIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries series = new MockBarSeries(numFunction, 22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, - 22.29, 22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, - 23.10, 23.33, 22.68, 23.10, 21.40, 20.17); + BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29, 22.15, 22.39, 22.38, + 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63, 23.82, 23.87, 23.65, 23.19, 23.10, 23.33, + 22.68, 23.10, 21.40, 20.17) + .build(); closePriceIndicator = new ClosePriceIndicator(series); } @Test public void getValueWithEma10AndEma20() { - PPOIndicator ppo = new PPOIndicator(closePriceIndicator, 10, 20); + var ppo = new PPOIndicator(closePriceIndicator, 10, 20); assertNumEquals(1.6778, ppo.getValue(21)); assertNumEquals(1.5669, ppo.getValue(22)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/PVOIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/PVOIndicatorTest.java index f8e5ca38e..e075c6ac5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/PVOIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/PVOIndicatorTest.java @@ -25,43 +25,37 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PVOIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries barSeries; - public PVOIndicatorTest(Function numFunction) { - super(numFunction); + public PVOIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(0, 10, numFunction)); - bars.add(new MockBar(0, 11, numFunction)); - bars.add(new MockBar(0, 12, numFunction)); - bars.add(new MockBar(0, 13, numFunction)); - bars.add(new MockBar(0, 150, numFunction)); - bars.add(new MockBar(0, 155, numFunction)); - bars.add(new MockBar(0, 160, numFunction)); - barSeries = new MockBarSeries(bars); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + barSeries.barBuilder().closePrice(0).volume(10).add(); + barSeries.barBuilder().closePrice(0).volume(11).add(); + barSeries.barBuilder().closePrice(0).volume(12).add(); + barSeries.barBuilder().closePrice(0).volume(13).add(); + barSeries.barBuilder().closePrice(0).volume(150).add(); + barSeries.barBuilder().closePrice(0).volume(155).add(); + barSeries.barBuilder().closePrice(0).volume(160).add(); } @Test public void createPvoIndicator() { - PVOIndicator pvo = new PVOIndicator(barSeries); + var pvo = new PVOIndicator(barSeries); assertNumEquals(0.791855204, pvo.getValue(1)); assertNumEquals(2.164434756, pvo.getValue(2)); assertNumEquals(3.925400464, pvo.getValue(3)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ParabolicSarIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ParabolicSarIndicatorTest.java index 2d48d6231..7dba99e23 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ParabolicSarIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ParabolicSarIndicatorTest.java @@ -28,42 +28,74 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.ArrayList; import java.util.List; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ParabolicSarIndicatorTest extends AbstractIndicatorTest, Num> { - public ParabolicSarIndicatorTest(Function numFunction) { - super(numFunction); + public ParabolicSarIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void growingBarSeriesTest() { ZonedDateTime now = ZonedDateTime.now(); - List bars = new ArrayList<>(); - bars.add(new MockBar(now, 74.5, 75.1, 75.11, 74.06, 0, 0, 0, numFunction)); + var mockBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + mockBarSeries.barBuilder() + .endTime(now) + .openPrice(74.5) + .closePrice(75.1) + .highPrice(75.11) + .lowPrice(74.06) + .build(); - MockBarSeries mockBarSeries = new MockBarSeries(bars); mockBarSeries.setMaximumBarCount(3); - mockBarSeries.addBar(new MockBar(now.plusSeconds(1), 75.09, 75.9, 76.030000, 74.640000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(2), 79.99, 75.24, 76.269900, 75.060000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(3), 75.30, 75.17, 75.280000, 74.500000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(4), 75.16, 74.6, 75.310000, 74.540000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(5), 74.58, 74.1, 75.467000, 74.010000, 0, 0, 0, numFunction)); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(1)) + .openPrice(75.09) + .closePrice(75.9) + .highPrice(76.030000) + .lowPrice(74.640000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(2)) + .openPrice(79.99) + .closePrice(75.24) + .highPrice(76.269900) + .lowPrice(75.060000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(3)) + .openPrice(75.30) + .closePrice(75.17) + .highPrice(75.280000) + .lowPrice(74.500000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(4)) + .openPrice(75.16) + .closePrice(74.6) + .highPrice(75.310000) + .lowPrice(74.540000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(5)) + .openPrice(74.58) + .closePrice(74.1) + .highPrice(75.467000) + .lowPrice(74.010000) + .add(); - ParabolicSarIndicator sar = new ParabolicSarIndicator(mockBarSeries); + var sar = new ParabolicSarIndicator(mockBarSeries); assertEquals(NaN.NaN, sar.getValue(mockBarSeries.getBeginIndex())); assertEquals(NaN.NaN, sar.getValue(mockBarSeries.getRemovedBarsCount())); @@ -75,52 +107,183 @@ public void growingBarSeriesTest() { @Test public void startUpAndDownTrendTest() { ZonedDateTime now = ZonedDateTime.now(); - List bars = new ArrayList<>(); + var mockBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + // values of removable bars are much higher to be sure that they will not affect // the result. - bars.add(new MockBar(now.plusSeconds(1), 165.5, 175.1, 180.10, 170.1, 0, 0, 0, numFunction)); - bars.add(new MockBar(now.plusSeconds(2), 175.1, 185.1, 190.20, 180.2, 0, 0, 0, numFunction)); - bars.add(new MockBar(now.plusSeconds(3), 185.1, 195.1, 200.30, 190.3, 0, 0, 0, numFunction)); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(1)) + .openPrice(165.5) + .closePrice(175.1) + .highPrice(180.10) + .lowPrice(170.1) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(2)) + .openPrice(175.1) + .closePrice(185.1) + .highPrice(190.20) + .lowPrice(180.2) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(3)) + .openPrice(185.1) + .closePrice(195.1) + .highPrice(200.30) + .lowPrice(190.3) + .add(); - MockBarSeries mockBarSeries = new MockBarSeries(bars); mockBarSeries.setMaximumBarCount(21); - mockBarSeries.addBar(new MockBar(now.plusSeconds(4), 74.5, 75.1, 75.11, 74.06, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(5), 75.09, 75.9, 76.030000, 74.640000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(6), 79.99, 75.24, 76.269900, 75.060000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(7), 75.30, 75.17, 75.280000, 74.500000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(8), 75.16, 74.6, 75.310000, 74.540000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(9), 74.58, 74.1, 75.467000, 74.010000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(10), 74.01, 73.740000, 74.700000, 73.546000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(11), 73.71, 73.390000, 73.830000, 72.720000, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(12), 73.35, 73.25, 73.890000, 72.86, 0, 0, 0, numFunction)); - mockBarSeries.addBar(new MockBar(now.plusSeconds(13), 73.24, 74.36, 74.410000, 73, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(14), 74.36, 76.510000, 76.830000, 74.820000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(15), 76.5, 75.590000, 76.850000, 74.540000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(16), 75.60, 75.910000, 76.960000, 75.510000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(17), 75.82, 74.610000, 77.070000, 74.560000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(18), 74.75, 75.330000, 75.530000, 74.010000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(19), 75.33, 75.010000, 75.500000, 74.510000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(20), 75.0, 75.620000, 76.210000, 75.250000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(21), 75.63, 76.040000, 76.460000, 75.092800, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(22), 76.0, 76.450000, 76.450000, 75.435000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(23), 76.45, 76.260000, 76.470000, 75.840000, 0, 0, 0, numFunction)); - mockBarSeries - .addBar(new MockBar(now.plusSeconds(24), 76.30, 76.850000, 77.000000, 76.190000, 0, 0, 0, numFunction)); - - ParabolicSarIndicator sar = new ParabolicSarIndicator(mockBarSeries); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(4)) + .openPrice(74.5) + .closePrice(75.1) + .highPrice(75.11) + .lowPrice(74.06) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(5)) + .openPrice(75.09) + .closePrice(75.9) + .highPrice(76.030000) + .lowPrice(74.640000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(6)) + .openPrice(79.99) + .closePrice(75.24) + .highPrice(76.269900) + .lowPrice(75.060000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(7)) + .openPrice(75.30) + .closePrice(75.17) + .highPrice(75.280000) + .lowPrice(74.500000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(8)) + .openPrice(75.16) + .closePrice(74.6) + .highPrice(75.310000) + .lowPrice(74.540000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(9)) + .openPrice(74.58) + .closePrice(74.1) + .highPrice(75.467000) + .lowPrice(74.010000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(10)) + .openPrice(74.01) + .closePrice(73.740000) + .highPrice(74.700000) + .lowPrice(73.546000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(11)) + .openPrice(73.71) + .closePrice(73.390000) + .highPrice(73.830000) + .lowPrice(72.720000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(12)) + .openPrice(73.35) + .closePrice(73.25) + .highPrice(73.890000) + .lowPrice(72.86) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(13)) + .openPrice(73.24) + .closePrice(74.36) + .highPrice(74.410000) + .lowPrice(73) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(14)) + .openPrice(74.36) + .closePrice(76.510000) + .highPrice(76.830000) + .lowPrice(74.820000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(15)) + .openPrice(76.5) + .closePrice(75.590000) + .highPrice(76.850000) + .lowPrice(74.540000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(16)) + .openPrice(75.60) + .closePrice(75.910000) + .highPrice(76.960000) + .lowPrice(75.510000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(17)) + .openPrice(75.82) + .closePrice(74.610000) + .highPrice(77.070000) + .lowPrice(74.560000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(18)) + .openPrice(74.75) + .closePrice(75.330000) + .highPrice(75.530000) + .lowPrice(74.010000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(19)) + .openPrice(75.33) + .closePrice(75.010000) + .highPrice(75.500000) + .lowPrice(74.510000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(20)) + .openPrice(75.0) + .closePrice(75.620000) + .highPrice(76.210000) + .lowPrice(75.250000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(21)) + .openPrice(75.63) + .closePrice(76.040000) + .highPrice(76.460000) + .lowPrice(75.092800) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(22)) + .openPrice(76.0) + .closePrice(76.450000) + .highPrice(76.450000) + .lowPrice(75.435000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(23)) + .openPrice(76.45) + .closePrice(76.260000) + .highPrice(76.470000) + .lowPrice(75.840000) + .add(); + mockBarSeries.barBuilder() + .endTime(now.plusSeconds(24)) + .openPrice(76.30) + .closePrice(76.850000) + .highPrice(77.000000) + .lowPrice(76.190000) + .add(); + + var sar = new ParabolicSarIndicator(mockBarSeries); assertEquals(NaN.NaN, sar.getValue(mockBarSeries.getRemovedBarsCount())); // first bar in series assertNumEquals(74.06, sar.getValue(mockBarSeries.getRemovedBarsCount() + 1)); @@ -147,21 +310,34 @@ public void startUpAndDownTrendTest() { @Test public void startWithDownAndUpTrendTest() { - List bars = new ArrayList<>(); - bars.add(new MockBar(4261.48, 4285.08, 4485.39, 4200.74, numFunction)); // The first daily candle of BTCUSDT in + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(4261.48).closePrice(4285.08).highPrice(4485.39).lowPrice(4200.74).add(); // The + // first + // daily + // candle + // of + // BTCUSDT + // in // the Binance cryptocurrency exchange. // 17 Aug 2017 - bars.add(new MockBar(4285.08, 4108.37, 4371.52, 3938.77, numFunction)); // starting with down trend - bars.add(new MockBar(4108.37, 4139.98, 4184.69, 3850.00, numFunction)); // hold trend... - bars.add(new MockBar(4120.98, 4086.29, 4211.08, 4032.62, numFunction)); - bars.add(new MockBar(4069.13, 4016.00, 4119.62, 3911.79, numFunction)); - bars.add(new MockBar(4016.00, 4040.00, 4104.82, 3400.00, numFunction)); - bars.add(new MockBar(4040.00, 4114.01, 4265.80, 4013.89, numFunction)); - bars.add(new MockBar(4147.00, 4316.01, 4371.68, 4085.01, numFunction)); // switch to up trend - bars.add(new MockBar(4316.01, 4280.68, 4453.91, 4247.48, numFunction)); // hold trend - bars.add(new MockBar(4280.71, 4337.44, 4367.00, 4212.41, numFunction)); - - ParabolicSarIndicator sar = new ParabolicSarIndicator(new MockBarSeries(bars)); + series.barBuilder().openPrice(4285.08).closePrice(4108.37).highPrice(4371.52).lowPrice(3938.77).add(); // starting + // with + // down + // trend + series.barBuilder().openPrice(4108.37).closePrice(4139.98).highPrice(4184.69).lowPrice(3850.00).add(); // hold + // trend... + series.barBuilder().openPrice(4120.98).closePrice(4086.29).highPrice(4211.08).lowPrice(4032.62).add(); + series.barBuilder().openPrice(4069.13).closePrice(4016.00).highPrice(4119.62).lowPrice(3911.79).add(); + series.barBuilder().openPrice(4016.00).closePrice(4040.00).highPrice(4104.82).lowPrice(3400.00).add(); + series.barBuilder().openPrice(4040.00).closePrice(4114.01).highPrice(4265.80).lowPrice(4013.89).add(); + series.barBuilder().openPrice(4147.00).closePrice(4316.01).highPrice(4371.68).lowPrice(4085.01).add(); // switch + // to up + // trend + series.barBuilder().openPrice(4316.01).closePrice(4280.68).highPrice(4453.91).lowPrice(4247.48).add(); // hold + // trend + series.barBuilder().openPrice(4280.71).closePrice(4337.44).highPrice(4367.00).lowPrice(4212.41).add(); + + var sar = new ParabolicSarIndicator(series); assertEquals(NaN.NaN, sar.getValue(0)); assertNumEquals(4485.39000000, sar.getValue(1)); @@ -177,21 +353,21 @@ public void startWithDownAndUpTrendTest() { @Test public void testSameValueForSameIndex() { - List bars = new ArrayList<>(); - bars.add(new MockBar(4261.48, 4285.08, 4485.39, 4200.74, numFunction)); - bars.add(new MockBar(4285.08, 4108.37, 4371.52, 3938.77, numFunction)); - bars.add(new MockBar(4108.37, 4139.98, 4184.69, 3850.00, numFunction)); - bars.add(new MockBar(4120.98, 4086.29, 4211.08, 4032.62, numFunction)); - bars.add(new MockBar(4069.13, 4016.00, 4119.62, 3911.79, numFunction)); - bars.add(new MockBar(4016.00, 4040.00, 4104.82, 3400.00, numFunction)); - bars.add(new MockBar(4040.00, 4114.01, 4265.80, 4013.89, numFunction)); - bars.add(new MockBar(4147.00, 4316.01, 4371.68, 4085.01, numFunction)); - bars.add(new MockBar(4316.01, 4280.68, 4453.91, 4247.48, numFunction)); - bars.add(new MockBar(4280.71, 4337.44, 4367.00, 4212.41, numFunction)); - - final ParabolicSarIndicator parabolicSarIndicator = new ParabolicSarIndicator(new MockBarSeries(bars)); - - final List values = IntStream.range(0, bars.size()) + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(4261.48).closePrice(4285.08).highPrice(4485.39).lowPrice(4200.74).add(); + series.barBuilder().openPrice(4285.08).closePrice(4108.37).highPrice(4371.52).lowPrice(3938.77).add(); + series.barBuilder().openPrice(4108.37).closePrice(4139.98).highPrice(4184.69).lowPrice(3850.00).add(); + series.barBuilder().openPrice(4120.98).closePrice(4086.29).highPrice(4211.08).lowPrice(4032.62).add(); + series.barBuilder().openPrice(4069.13).closePrice(4016.00).highPrice(4119.62).lowPrice(3911.79).add(); + series.barBuilder().openPrice(4016.00).closePrice(4040.00).highPrice(4104.82).lowPrice(3400.00).add(); + series.barBuilder().openPrice(4040.00).closePrice(4114.01).highPrice(4265.80).lowPrice(4013.89).add(); + series.barBuilder().openPrice(4147.00).closePrice(4316.01).highPrice(4371.68).lowPrice(4085.01).add(); + series.barBuilder().openPrice(4316.01).closePrice(4280.68).highPrice(4453.91).lowPrice(4247.48).add(); + series.barBuilder().openPrice(4280.71).closePrice(4337.44).highPrice(4367.00).lowPrice(4212.41).add(); + + final ParabolicSarIndicator parabolicSarIndicator = new ParabolicSarIndicator(series); + + final List values = IntStream.range(0, series.getBarCount()) .mapToObj(parabolicSarIndicator::getValue) .collect(Collectors.toList()); @@ -209,4 +385,4 @@ public void testSameValueForSameIndex() { assertNumEquals(values.get(6), parabolicSarIndicator.getValue(6)); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/RAVIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/RAVIIndicatorTest.java index 439e110d9..9c7ae9549 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/RAVIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/RAVIIndicatorTest.java @@ -25,37 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class RAVIIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public RAVIIndicatorTest(Function numFunction) { - super(numFunction); + public RAVIIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 110.00, 109.27, 104.69, 107.07, 107.92, 107.95, 108.70, 107.97, 106.09, - 106.03, 108.65, 109.54, 112.26, 114.38, 117.94 - - ); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(110.00, 109.27, 104.69, 107.07, 107.92, 107.95, 108.70, 107.97, 106.09, 106.03, 108.65, + 109.54, 112.26, 114.38, 117.94) + .build(); } @Test public void ravi() { - ClosePriceIndicator closePrice = new ClosePriceIndicator(data); - RAVIIndicator ravi = new RAVIIndicator(closePrice, 3, 8); + var closePrice = new ClosePriceIndicator(data); + var ravi = new RAVIIndicator(closePrice, 3, 8); assertNumEquals(0, ravi.getValue(0)); assertNumEquals(0, ravi.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ROCIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ROCIndicatorTest.java index 70d0b9100..d4588e40c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ROCIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ROCIndicatorTest.java @@ -25,14 +25,13 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ROCIndicatorTest extends AbstractIndicatorTest, Num> { @@ -42,18 +41,19 @@ public class ROCIndicatorTest extends AbstractIndicatorTest, Num> private ClosePriceIndicator closePrice; - public ROCIndicatorTest(Function numFunction) { - super(numFunction); + public ROCIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - closePrice = new ClosePriceIndicator(new MockBarSeries(numFunction, closePriceValues)); + closePrice = new ClosePriceIndicator( + new MockBarSeriesBuilder().withNumFactory(numFactory).withData(closePriceValues).build()); } @Test public void getValueWhenBarCountIs12() { - ROCIndicator roc = new ROCIndicator(closePrice, 12); + var roc = new ROCIndicator(closePrice, 12); // Incomplete time frame assertNumEquals(0, roc.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/RSIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/RSIIndicatorTest.java index efcd12766..ff3870877 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/RSIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/RSIIndicatorTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -37,47 +35,46 @@ import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.GainIndicator; import org.ta4j.core.indicators.helpers.LossIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class RSIIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; private final ExternalIndicatorTest xls; - // private ExternalIndicatorTest sql; - public RSIIndicatorTest(Function numFunction) { - super((data, params) -> new RSIIndicator((Indicator) data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "RSI.xls", 10, numFunction); - // sql = new SQLIndicatorTest(this.getClass(), "RSI.db", username, pass, table, - // column); + public RSIIndicatorTest(NumFactory numFactory) { + super((data, params) -> new RSIIndicator((Indicator) data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "RSI.xls", 10, numFactory); } @Before public void setUp() throws Exception { - data = new MockBarSeries(numFunction, 50.45, 50.30, 50.20, 50.15, 50.05, 50.06, 50.10, 50.08, 50.03, 50.07, - 50.01, 50.14, 50.22, 50.43, 50.50, 50.56, 50.52, 50.70, 50.55, 50.62, 50.90, 50.82, 50.86, 51.20, 51.30, - 51.10); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(50.45, 50.30, 50.20, 50.15, 50.05, 50.06, 50.10, 50.08, 50.03, 50.07, 50.01, 50.14, 50.22, + 50.43, 50.50, 50.56, 50.52, 50.70, 50.55, 50.62, 50.90, 50.82, 50.86, 51.20, 51.30, 51.10) + .build(); } @Test public void firstValueShouldBeZero() throws Exception { Indicator indicator = getIndicator(new ClosePriceIndicator(data), 14); - assertEquals(data.zero(), indicator.getValue(0)); + assertEquals(numFactory.zero(), indicator.getValue(0)); } @Test public void hundredIfNoLoss() throws Exception { Indicator indicator = getIndicator(new ClosePriceIndicator(data), 1); - assertEquals(data.hundred(), indicator.getValue(14)); - assertEquals(data.hundred(), indicator.getValue(15)); + assertEquals(numFactory.hundred(), indicator.getValue(14)); + assertEquals(numFactory.hundred(), indicator.getValue(15)); } @Test public void zeroIfNoGain() throws Exception { Indicator indicator = getIndicator(new ClosePriceIndicator(data), 1); - assertEquals(data.zero(), indicator.getValue(1)); - assertEquals(data.zero(), indicator.getValue(2)); + assertEquals(numFactory.zero(), indicator.getValue(1)); + assertEquals(numFactory.zero(), indicator.getValue(2)); } @Test @@ -118,13 +115,14 @@ public void xlsTest() throws Exception { } @Test - public void onlineExampleTest() throws Exception { + public void onlineExampleTest() { // from // http://cns.bu.edu/~gsc/CN710/fincast/Technical%20_indicators/Relative%20Strength%20Index%20(RSI).htm // which uses a different calculation of RSI than ta4j - BarSeries series = new MockBarSeries(numFunction, 46.1250, 47.1250, 46.4375, 46.9375, 44.9375, 44.2500, 44.6250, - 45.7500, 47.8125, 47.5625, 47.0000, 44.5625, 46.3125, 47.6875, 46.6875, 45.6875, 43.0625, 43.5625, - 44.8750, 43.6875); + BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(46.1250, 47.1250, 46.4375, 46.9375, 44.9375, 44.2500, 44.6250, 45.7500, 47.8125, 47.5625, + 47.0000, 44.5625, 46.3125, 47.6875, 46.6875, 45.6875, 43.0625, 43.5625, 44.8750, 43.6875) + .build(); // ta4j RSI uses MMA for average gain and loss // then uses simple division of the two for RS Indicator indicator = getIndicator(new ClosePriceIndicator(series), 14); @@ -155,15 +153,15 @@ public void onlineExampleTest() throws Exception { // second online calculation uses MMAs // MMA of average gain double dividend = avgGain.getValue(14) - .multipliedBy(series.numOf(13)) + .multipliedBy(series.numFactory().numOf(13)) .plus(gain.getValue(15)) - .dividedBy(series.numOf(14)) + .dividedBy(series.numFactory().numOf(14)) .doubleValue(); // MMA of average loss double divisor = avgLoss.getValue(14) - .multipliedBy(series.numOf(13)) + .multipliedBy(series.numFactory().numOf(13)) .plus(loss.getValue(15)) - .dividedBy(series.numOf(14)) + .dividedBy(series.numFactory().numOf(14)) .doubleValue(); onlineRs = dividend / divisor; assertEquals(0.9409, onlineRs, TestUtils.GENERAL_OFFSET); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/RWIHighIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/RWIHighIndicatorTest.java index 494c21051..6a8e68372 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/RWIHighIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/RWIHighIndicatorTest.java @@ -25,12 +25,11 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Testing the RWIHighIndicator @@ -43,9 +42,9 @@ public class RWIHighIndicatorTest extends AbstractIndicatorTest */ private final ExternalIndicatorTest xls; - public RWIHighIndicatorTest(Function numFunction) { - super((data, params) -> new RWIHighIndicator(data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "RWIHL.xls", 8, numFunction); + public RWIHighIndicatorTest(NumFactory numFactory) { + super((data, params) -> new RWIHighIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "RWIHL.xls", 8, numFactory); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/RWILowIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/RWILowIndicatorTest.java index d4f1a3e73..4f44df6c7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/RWILowIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/RWILowIndicatorTest.java @@ -25,12 +25,11 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; /** * Testing the RWILowIndicator @@ -43,9 +42,9 @@ public class RWILowIndicatorTest extends AbstractIndicatorTest { */ private final ExternalIndicatorTest xls; - public RWILowIndicatorTest(Function numFunction) { - super((data, params) -> new RWILowIndicator(data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "RWIHL.xls", 9, numFunction); + public RWILowIndicatorTest(NumFactory numFactory) { + super((data, params) -> new RWILowIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "RWIHL.xls", 9, numFactory); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/SMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/SMAIndicatorTest.java index 1d800989e..8ce7c50d2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/SMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/SMAIndicatorTest.java @@ -27,8 +27,6 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -36,23 +34,26 @@ import org.ta4j.core.Indicator; import org.ta4j.core.TestUtils; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class SMAIndicatorTest extends AbstractIndicatorTest, Num> { private final ExternalIndicatorTest xls; - public SMAIndicatorTest(Function numFunction) throws Exception { - super((data, params) -> new SMAIndicator((Indicator) data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "SMA.xls", 6, numFunction); + public SMAIndicatorTest(NumFactory numFactory) throws Exception { + super((data, params) -> new SMAIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "SMA.xls", 6, numFactory); } private BarSeries data; @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorDIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorDIndicatorTest.java index 2bccbd65e..8ed2d850a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorDIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorDIndicatorTest.java @@ -25,54 +25,48 @@ import static junit.framework.TestCase.assertEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StochasticOscillatorDIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public StochasticOscillatorDIndicatorTest(Function function) { - super(function); + public StochasticOscillatorDIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(44.98, 119.13, 119.50, 116.00, numFunction)); - bars.add(new MockBar(45.05, 116.75, 119.94, 116.00, numFunction)); - bars.add(new MockBar(45.11, 113.50, 118.44, 111.63, numFunction)); - bars.add(new MockBar(45.19, 111.56, 114.19, 110.06, numFunction)); - bars.add(new MockBar(45.12, 112.25, 112.81, 109.63, numFunction)); - bars.add(new MockBar(45.15, 110.00, 113.44, 109.13, numFunction)); - bars.add(new MockBar(45.13, 113.50, 115.81, 110.38, numFunction)); - bars.add(new MockBar(45.12, 117.13, 117.50, 114.06, numFunction)); - bars.add(new MockBar(45.15, 115.63, 118.44, 114.81, numFunction)); - bars.add(new MockBar(45.24, 114.13, 116.88, 113.13, numFunction)); - bars.add(new MockBar(45.43, 118.81, 119.00, 116.19, numFunction)); - bars.add(new MockBar(45.43, 117.38, 119.75, 117.00, numFunction)); - bars.add(new MockBar(45.58, 119.13, 119.13, 116.88, numFunction)); - bars.add(new MockBar(45.58, 115.38, 119.44, 114.56, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(119.13).highPrice(119.50).lowPrice(116.00).add(); + data.barBuilder().openPrice(45.05).closePrice(116.75).highPrice(119.94).lowPrice(116.00).add(); + data.barBuilder().openPrice(45.11).closePrice(113.50).highPrice(118.44).lowPrice(111.63).add(); + data.barBuilder().openPrice(45.19).closePrice(111.56).highPrice(114.19).lowPrice(110.06).add(); + data.barBuilder().openPrice(45.12).closePrice(112.25).highPrice(112.81).lowPrice(109.63).add(); + data.barBuilder().openPrice(45.15).closePrice(110.00).highPrice(113.44).lowPrice(109.13).add(); + data.barBuilder().openPrice(45.13).closePrice(113.50).highPrice(115.81).lowPrice(110.38).add(); + data.barBuilder().openPrice(45.12).closePrice(117.13).highPrice(117.50).lowPrice(114.06).add(); + data.barBuilder().openPrice(45.15).closePrice(115.63).highPrice(118.44).lowPrice(114.81).add(); + data.barBuilder().openPrice(45.24).closePrice(114.13).highPrice(116.88).lowPrice(113.13).add(); + data.barBuilder().openPrice(45.43).closePrice(118.81).highPrice(119.00).lowPrice(116.19).add(); + data.barBuilder().openPrice(45.43).closePrice(117.38).highPrice(119.75).lowPrice(117.00).add(); + data.barBuilder().openPrice(45.58).closePrice(119.13).highPrice(119.13).lowPrice(116.88).add(); + data.barBuilder().openPrice(45.58).closePrice(115.38).highPrice(119.44).lowPrice(114.56).add(); - data = new BaseBarSeries(bars); } @Test public void stochasticOscilatorDParam14UsingSMA3AndGenericConstructer() { - StochasticOscillatorKIndicator sof = new StochasticOscillatorKIndicator(data, 14); - SMAIndicator sma = new SMAIndicator(sof, 3); - StochasticOscillatorDIndicator sos = new StochasticOscillatorDIndicator(sma); + var sof = new StochasticOscillatorKIndicator(data, 14); + var sma = new SMAIndicator(sof, 3); + var sos = new StochasticOscillatorDIndicator(sma); assertEquals(sma.getValue(0), sos.getValue(0)); assertEquals(sma.getValue(1), sos.getValue(1)); @@ -82,9 +76,9 @@ public void stochasticOscilatorDParam14UsingSMA3AndGenericConstructer() { @Test public void stochasticOscilatorDParam14UsingSMA3() { - StochasticOscillatorKIndicator sof = new StochasticOscillatorKIndicator(data, 14); - StochasticOscillatorDIndicator sos = new StochasticOscillatorDIndicator(sof); - SMAIndicator sma = new SMAIndicator(sof, 3); + var sof = new StochasticOscillatorKIndicator(data, 14); + var sos = new StochasticOscillatorDIndicator(sof); + var sma = new SMAIndicator(sof, 3); assertEquals(sma.getValue(0), sos.getValue(0)); assertEquals(sma.getValue(1), sos.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorKIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorKIndicatorTest.java index d956968b5..2963533d6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorKIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticOscillatorKIndicatorTest.java @@ -25,53 +25,47 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StochasticOscillatorKIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public StochasticOscillatorKIndicatorTest(Function function) { - super(function); + public StochasticOscillatorKIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); - List bars = new ArrayList(); - bars.add(new MockBar(44.98, 119.13, 119.50, 116.00, numFunction)); - bars.add(new MockBar(45.05, 116.75, 119.94, 116.00, numFunction)); - bars.add(new MockBar(45.11, 113.50, 118.44, 111.63, numFunction)); - bars.add(new MockBar(45.19, 111.56, 114.19, 110.06, numFunction)); - bars.add(new MockBar(45.12, 112.25, 112.81, 109.63, numFunction)); - bars.add(new MockBar(45.15, 110.00, 113.44, 109.13, numFunction)); - bars.add(new MockBar(45.13, 113.50, 115.81, 110.38, numFunction)); - bars.add(new MockBar(45.12, 117.13, 117.50, 114.06, numFunction)); - bars.add(new MockBar(45.15, 115.63, 118.44, 114.81, numFunction)); - bars.add(new MockBar(45.24, 114.13, 116.88, 113.13, numFunction)); - bars.add(new MockBar(45.43, 118.81, 119.00, 116.19, numFunction)); - bars.add(new MockBar(45.43, 117.38, 119.75, 117.00, numFunction)); - bars.add(new MockBar(45.58, 119.13, 119.13, 116.88, numFunction)); - bars.add(new MockBar(45.58, 115.38, 119.44, 114.56, numFunction)); + data.barBuilder().openPrice(44.98).closePrice(119.13).highPrice(119.50).lowPrice(116.00).add(); + data.barBuilder().openPrice(45.05).closePrice(116.75).highPrice(119.94).lowPrice(116.00).add(); + data.barBuilder().openPrice(45.11).closePrice(113.50).highPrice(118.44).lowPrice(111.63).add(); + data.barBuilder().openPrice(45.19).closePrice(111.56).highPrice(114.19).lowPrice(110.06).add(); + data.barBuilder().openPrice(45.12).closePrice(112.25).highPrice(112.81).lowPrice(109.63).add(); + data.barBuilder().openPrice(45.15).closePrice(110.00).highPrice(113.44).lowPrice(109.13).add(); + data.barBuilder().openPrice(45.13).closePrice(113.50).highPrice(115.81).lowPrice(110.38).add(); + data.barBuilder().openPrice(45.12).closePrice(117.13).highPrice(117.50).lowPrice(114.06).add(); + data.barBuilder().openPrice(45.15).closePrice(115.63).highPrice(118.44).lowPrice(114.81).add(); + data.barBuilder().openPrice(45.24).closePrice(114.13).highPrice(116.88).lowPrice(113.13).add(); + data.barBuilder().openPrice(45.43).closePrice(118.81).highPrice(119.00).lowPrice(116.19).add(); + data.barBuilder().openPrice(45.43).closePrice(117.38).highPrice(119.75).lowPrice(117.00).add(); + data.barBuilder().openPrice(45.58).closePrice(119.13).highPrice(119.13).lowPrice(116.88).add(); + data.barBuilder().openPrice(45.58).closePrice(115.38).highPrice(119.44).lowPrice(114.56).add(); - data = new BaseBarSeries(bars); } @Test public void stochasticOscilatorKParam14() { - StochasticOscillatorKIndicator sof = new StochasticOscillatorKIndicator(data, 14); + var sof = new StochasticOscillatorKIndicator(data, 14); assertNumEquals(313 / 3.5, sof.getValue(0)); assertNumEquals(1000 / 10.81, sof.getValue(12)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticRSIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticRSIIndicatorTest.java index 48cb823b1..b94c85c97 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticRSIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/StochasticRSIIndicatorTest.java @@ -26,24 +26,23 @@ import static org.ta4j.core.TestUtils.assertIndicatorEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StochasticRSIIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; private final ExternalIndicatorTest xls; - public StochasticRSIIndicatorTest(Function numFunction) { - super((data, params) -> new StochasticRSIIndicator(data, (int) params[0]), numFunction); - xls = new XLSIndicatorTest(this.getClass(), "AAPL_StochRSI.xls", 15, numFunction); + public StochasticRSIIndicatorTest(NumFactory numFactory) { + super((data, params) -> new StochasticRSIIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "AAPL_StochRSI.xls", 15, numFactory); } @Test @@ -59,14 +58,15 @@ public void xlsTest() throws Exception { @Before public void setUp() { - data = new MockBarSeries(numFunction, 50.45, 50.30, 50.20, 50.15, 50.05, 50.06, 50.10, 50.08, 50.03, 50.07, - 50.01, 50.14, 50.22, 50.43, 50.50, 50.56, 50.52, 50.70, 50.55, 50.62, 50.90, 50.82, 50.86, 51.20, 51.30, - 51.10); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(50.45, 50.30, 50.20, 50.15, 50.05, 50.06, 50.10, 50.08, 50.03, 50.07, 50.01, 50.14, 50.22, + 50.43, 50.50, 50.56, 50.52, 50.70, 50.55, 50.62, 50.90, 50.82, 50.86, 51.20, 51.30, 51.10) + .build(); } @Test public void stochasticRSI() { - StochasticRSIIndicator srsi = new StochasticRSIIndicator(data, 14); + var srsi = new StochasticRSIIndicator(data, 14); assertNumEquals(1, srsi.getValue(15)); assertNumEquals(0.9460, srsi.getValue(16)); assertNumEquals(1, srsi.getValue(17)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/TripleEMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/TripleEMAIndicatorTest.java index 3ea8f1038..cda4e7541 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/TripleEMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/TripleEMAIndicatorTest.java @@ -25,34 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TripleEMAIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePrice; - public TripleEMAIndicatorTest(Function numFunction) { - super(numFunction); + public TripleEMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 0.73, 0.72, 0.86, 0.72, 0.62, 0.76, 0.84, 0.69, 0.65, 0.71, - 0.53, 0.73, 0.77, 0.67, 0.68); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(0.73, 0.72, 0.86, 0.72, 0.62, 0.76, 0.84, 0.69, 0.65, 0.71, 0.53, 0.73, 0.77, 0.67, 0.68) + .build(); closePrice = new ClosePriceIndicator(data); } @Test public void tripleEMAUsingBarCount5UsingClosePrice() { - TripleEMAIndicator tripleEma = new TripleEMAIndicator(closePrice, 5); + var tripleEma = new TripleEMAIndicator(closePrice, 5); assertNumEquals(0.73, tripleEma.getValue(0)); assertNumEquals(0.7229, tripleEma.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/UlcerIndexIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/UlcerIndexIndicatorTest.java index 3a55ec7c5..e4ea88098 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/UlcerIndexIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/UlcerIndexIndicatorTest.java @@ -25,35 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class UlcerIndexIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries ibmData; - public UlcerIndexIndicatorTest(Function numFunction) { - super(numFunction); + public UlcerIndexIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - ibmData = new MockBarSeries(numFunction, 194.75, 195.00, 195.10, 194.46, 190.60, 188.86, 185.47, 184.46, 182.31, - 185.22, 184.00, 182.87, 187.45, 194.51, 191.63, 190.02, 189.53, 190.27, 193.13, 195.55, 195.84, 195.15, - 194.35, 193.62, 197.68, 197.91, 199.08, 199.03, 198.42, 199.29, 199.01, 198.29, 198.40, 200.84, 201.22, - 200.50, 198.65, 197.25, 195.70, 197.77, 195.69, 194.87, 195.08); + ibmData = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(194.75, 195.00, 195.10, 194.46, 190.60, 188.86, 185.47, 184.46, 182.31, 185.22, 184.00, + 182.87, 187.45, 194.51, 191.63, 190.02, 189.53, 190.27, 193.13, 195.55, 195.84, 195.15, 194.35, + 193.62, 197.68, 197.91, 199.08, 199.03, 198.42, 199.29, 199.01, 198.29, 198.40, 200.84, 201.22, + 200.50, 198.65, 197.25, 195.70, 197.77, 195.69, 194.87, 195.08) + .build(); } @Test public void ulcerIndexUsingBarCount14UsingIBMData() { - UlcerIndexIndicator ulcer = new UlcerIndexIndicator(new ClosePriceIndicator(ibmData), 14); + var ulcer = new UlcerIndexIndicator(new ClosePriceIndicator(ibmData), 14); assertNumEquals(0, ulcer.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/WMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/WMAIndicatorTest.java index 7f8ff38ae..3fd966526 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/WMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/WMAIndicatorTest.java @@ -25,24 +25,22 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class WMAIndicatorTest extends AbstractIndicatorTest, Num> { - public WMAIndicatorTest(Function numFunction) { - super(numFunction); + public WMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void calculate() { - MockBarSeries series = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d, 6d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 2d, 3d, 4d, 5d, 6d).build(); Indicator close = new ClosePriceIndicator(series); Indicator wmaIndicator = new WMAIndicator(close, 3); @@ -56,7 +54,7 @@ public void calculate() { @Test public void wmaWithBarCountGreaterThanSeriesSize() { - MockBarSeries series = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d, 6d); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d, 2d, 3d, 4d, 5d, 6d).build(); Indicator close = new ClosePriceIndicator(series); Indicator wmaIndicator = new WMAIndicator(close, 55); @@ -72,8 +70,10 @@ public void wmaWithBarCountGreaterThanSeriesSize() { public void wmaUsingBarCount9UsingClosePrice() { // Example from // http://traders.com/Documentation/FEEDbk_docs/2010/12/TradingIndexesWithHullMA.xls - BarSeries data = new MockBarSeries(numFunction, 84.53, 87.39, 84.55, 82.83, 82.58, 83.74, 83.33, 84.57, 86.98, - 87.10, 83.11, 83.60, 83.66, 82.76, 79.22, 79.03, 78.18, 77.42, 74.65, 77.48, 76.87); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(84.53, 87.39, 84.55, 82.83, 82.58, 83.74, 83.33, 84.57, 86.98, 87.10, 83.11, 83.60, 83.66, + 82.76, 79.22, 79.03, 78.18, 77.42, 74.65, 77.48, 76.87) + .build(); WMAIndicator wma = new WMAIndicator(new ClosePriceIndicator(data), 9); assertNumEquals(84.4958, wma.getValue(8)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/WilliamsRIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/WilliamsRIndicatorTest.java index 3e978be86..eaa6bd9b4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/WilliamsRIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/WilliamsRIndicatorTest.java @@ -25,53 +25,47 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.HighPriceIndicator; import org.ta4j.core.indicators.helpers.LowPriceIndicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class WilliamsRIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public WilliamsRIndicatorTest(Function numFunction) { - super(numFunction); + public WilliamsRIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).add(); - data = new BaseBarSeries(bars); } @Test public void williamsRUsingBarCount5UsingClosePrice() { - WilliamsRIndicator wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 5, new HighPriceIndicator(data), + var wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 5, new HighPriceIndicator(data), new LowPriceIndicator(data)); assertNumEquals(-47.2222, wr.getValue(4)); @@ -86,7 +80,7 @@ public void williamsRUsingBarCount5UsingClosePrice() { @Test public void williamsRUsingBarCount10UsingClosePrice() { - WilliamsRIndicator wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 10, new HighPriceIndicator(data), + var wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 10, new HighPriceIndicator(data), new LowPriceIndicator(data)); assertNumEquals(-4.0816, wr.getValue(9)); @@ -98,7 +92,7 @@ public void williamsRUsingBarCount10UsingClosePrice() { @Test public void valueLessThenBarCount() { - WilliamsRIndicator wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 100, new HighPriceIndicator(data), + var wr = new WilliamsRIndicator(new ClosePriceIndicator(data), 100, new HighPriceIndicator(data), new LowPriceIndicator(data)); assertNumEquals(-100d * (0.12 / 0.21), wr.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/XLSIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/XLSIndicatorTest.java index ec24b62e3..dd026d17c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/XLSIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/XLSIndicatorTest.java @@ -30,6 +30,7 @@ import org.ta4j.core.Indicator; import org.ta4j.core.XlsTestsUtils; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class XLSIndicatorTest implements ExternalIndicatorTest { @@ -37,7 +38,7 @@ public class XLSIndicatorTest implements ExternalIndicatorTest { private final String fileName; private final int column; private BarSeries cachedSeries = null; - private final Function numFunction; + private final NumFactory numFactory; /** * Constructor. @@ -46,11 +47,11 @@ public class XLSIndicatorTest implements ExternalIndicatorTest { * @param fileName file name of the file containing the workbook * @param column column number containing the calculated indicator values */ - public XLSIndicatorTest(Class clazz, String fileName, int column, Function numFunction) { + public XLSIndicatorTest(Class clazz, String fileName, int column, NumFactory numFactory) { this.clazz = clazz; this.fileName = fileName; this.column = column; - this.numFunction = numFunction; + this.numFactory = numFactory; } /** @@ -62,7 +63,7 @@ public XLSIndicatorTest(Class clazz, String fileName, int column, Function getIndicator(Object... params) throws Exception { - return XlsTestsUtils.getIndicator(clazz, fileName, column, getSeries().function(), params); + return XlsTestsUtils.getIndicator(clazz, fileName, column, getSeries().numFactory(), params); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ZLEMAIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ZLEMAIndicatorTest.java index 37145dbd2..00ceff296 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ZLEMAIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ZLEMAIndicatorTest.java @@ -26,32 +26,33 @@ import static junit.framework.TestCase.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ZLEMAIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public ZLEMAIndicatorTest(Function numFunction) { - super(numFunction); + public ZLEMAIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 10, 15, 20, 18, 17, 18, 15, 12, 10, 8, 5, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(10, 15, 20, 18, 17, 18, 15, 12, 10, 8, 5, 2) + .build(); } @Test public void ZLEMAUsingBarCount10UsingClosePrice() { - ZLEMAIndicator zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); + var zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); assertNumEquals(11.9091, zlema.getValue(9)); assertNumEquals(8.8347, zlema.getValue(10)); @@ -60,14 +61,14 @@ public void ZLEMAUsingBarCount10UsingClosePrice() { @Test public void ZLEMAFirstValueShouldBeEqualsToFirstDataValue() { - ZLEMAIndicator zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); + var zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); assertNumEquals(10, zlema.getValue(0)); } @Test public void valuesLessThanBarCountMustBeEqualsToSMAValues() { - ZLEMAIndicator zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); - SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(data), 10); + var zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 10); + var sma = new SMAIndicator(new ClosePriceIndicator(data), 10); for (int i = 0; i < 9; i++) { assertEquals(sma.getValue(i), zlema.getValue(i)); @@ -76,7 +77,7 @@ public void valuesLessThanBarCountMustBeEqualsToSMAValues() { @Test public void smallBarCount() { - ZLEMAIndicator zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 1); + var zlema = new ZLEMAIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(10, zlema.getValue(0)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/ADXIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/ADXIndicatorTest.java index b877d3852..545bf8547 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/ADXIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/ADXIndicatorTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; @@ -36,14 +34,15 @@ import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.XLSIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ADXIndicatorTest extends AbstractIndicatorTest { private final ExternalIndicatorTest xls; - public ADXIndicatorTest(Function nf) throws Exception { - super((data, params) -> new ADXIndicator((BarSeries) data, (int) params[0], (int) params[1]), nf); - xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 15, numFunction); + public ADXIndicatorTest(NumFactory numFactory) { + super((data, params) -> new ADXIndicator(data, (int) params[0], (int) params[1]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 15, this.numFactory); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDIIndicatorTest.java index 8ab1d6298..b13d4be77 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDIIndicatorTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; @@ -36,14 +34,15 @@ import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.XLSIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MinusDIIndicatorTest extends AbstractIndicatorTest { private final ExternalIndicatorTest xls; - public MinusDIIndicatorTest(Function nf) { + public MinusDIIndicatorTest(NumFactory nf) { super((data, params) -> new MinusDIIndicator(data, (int) params[0]), nf); - xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 13, numFunction); + xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 13, numFactory); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDMIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDMIndicatorTest.java index a1208d0d2..16c8b77f4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDMIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/MinusDMIndicatorTest.java @@ -25,68 +25,59 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MinusDMIndicatorTest extends AbstractIndicatorTest, Num> { - public MinusDMIndicatorTest(Function numFunction) { - super(numFunction); + public MinusDMIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void zeroDirectionalMovement() { - MockBar yesterdayBar = new MockBar(0, 0, 10, 2, numFunction); - MockBar todayBar = new MockBar(0, 0, 6, 6, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); - MinusDMIndicator down = new MinusDMIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(0).lowPrice(0).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(0).lowPrice(0).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); + var down = new MinusDMIndicator(series); assertNumEquals(0, down.getValue(1)); } @Test public void zeroDirectionalMovement2() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 12, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 6, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(12).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(6).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); MinusDMIndicator down = new MinusDMIndicator(series); assertNumEquals(0, down.getValue(1)); } @Test public void zeroDirectionalMovement3() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 6, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 4, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(6).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(4).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); MinusDMIndicator down = new MinusDMIndicator(series); assertNumEquals(0, down.getValue(1)); } @Test public void positiveDirectionalMovement() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 20, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 4, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(20).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(4).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); MinusDMIndicator down = new MinusDMIndicator(series); assertNumEquals(16, down.getValue(1)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDIIndicatorTest.java index b9a6a05f0..6a9e03473 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDIIndicatorTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.ExternalIndicatorTest; @@ -36,14 +34,15 @@ import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.XLSIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PlusDIIndicatorTest extends AbstractIndicatorTest { private final ExternalIndicatorTest xls; - public PlusDIIndicatorTest(Function nf) throws Exception { - super((data, params) -> new PlusDIIndicator((BarSeries) data, (int) params[0]), nf); - xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 12, numFunction); + public PlusDIIndicatorTest(NumFactory numFactory) { + super((data, params) -> new PlusDIIndicator(data, (int) params[0]), numFactory); + xls = new XLSIndicatorTest(this.getClass(), "ADX.xls", 12, numFactory); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDMIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDMIndicatorTest.java index 88ab6e23f..34c7d4d69 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDMIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/adx/PlusDMIndicatorTest.java @@ -25,69 +25,64 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PlusDMIndicatorTest extends AbstractIndicatorTest, Num> { - public PlusDMIndicatorTest(Function numFunction) { - super(numFunction); + public PlusDMIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void zeroDirectionalMovement() { - MockBar yesterdayBar = new MockBar(0, 0, 10, 2, numFunction); - MockBar todayBar = new MockBar(0, 0, 6, 6, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); - PlusDMIndicator dup = new PlusDMIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(10).lowPrice(2).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(6).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); + + var dup = new PlusDMIndicator(series); assertNumEquals(0, dup.getValue(1)); } @Test public void zeroDirectionalMovement2() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 12, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 6, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); - PlusDMIndicator dup = new PlusDMIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(12).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(6).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); + + var dup = new PlusDMIndicator(series); assertNumEquals(0, dup.getValue(1)); } @Test public void zeroDirectionalMovement3() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 20, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 4, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); - PlusDMIndicator dup = new PlusDMIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(20).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(4).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); + + var dup = new PlusDMIndicator(series); assertNumEquals(0, dup.getValue(1)); } @Test public void positiveDirectionalMovement() { - MockBar yesterdayBar = new MockBar(0, 0, 6, 6, numFunction); - MockBar todayBar = new MockBar(0, 0, 12, 4, numFunction); - List bars = new ArrayList(); - bars.add(yesterdayBar); - bars.add(todayBar); - MockBarSeries series = new MockBarSeries(bars); - PlusDMIndicator dup = new PlusDMIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + var yesterdayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(6).lowPrice(6).build(); + var todayBar = series.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(4).build(); + series.addBar(yesterdayBar); + series.addBar(todayBar); + + var dup = new PlusDMIndicator(series); assertNumEquals(6, dup.getValue(1)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java index dd0ef0466..f5e19b7c9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java @@ -28,53 +28,193 @@ import static org.ta4j.core.num.NaN.NaN; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AroonDownIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public AroonDownIndicatorTest(Function numFunction) { + public AroonDownIndicatorTest(NumFactory numFunction) { super(null, numFunction); } @Before public void init() { - data = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("Aroon data").build(); - data.addBar(ZonedDateTime.now().plusDays(1), 168.28, 169.87, 167.15, 169.64, 0); - data.addBar(ZonedDateTime.now().plusDays(2), 168.84, 169.36, 168.2, 168.71, 0); - data.addBar(ZonedDateTime.now().plusDays(3), 168.88, 169.29, 166.41, 167.74, 0); - data.addBar(ZonedDateTime.now().plusDays(4), 168, 168.38, 166.18, 166.32, 0); - data.addBar(ZonedDateTime.now().plusDays(5), 166.89, 167.7, 166.33, 167.24, 0); - data.addBar(ZonedDateTime.now().plusDays(6), 165.25, 168.43, 165, 168.05, 0); - data.addBar(ZonedDateTime.now().plusDays(7), 168.17, 170.18, 167.63, 169.92, 0); - data.addBar(ZonedDateTime.now().plusDays(8), 170.42, 172.15, 170.06, 171.97, 0); - data.addBar(ZonedDateTime.now().plusDays(9), 172.41, 172.92, 171.31, 172.02, 0); - data.addBar(ZonedDateTime.now().plusDays(10), 171.2, 172.39, 169.55, 170.72, 0); - data.addBar(ZonedDateTime.now().plusDays(11), 170.91, 172.48, 169.57, 172.09, 0); - data.addBar(ZonedDateTime.now().plusDays(12), 171.8, 173.31, 170.27, 173.21, 0); - data.addBar(ZonedDateTime.now().plusDays(13), 173.09, 173.49, 170.8, 170.95, 0); - data.addBar(ZonedDateTime.now().plusDays(14), 172.41, 173.89, 172.2, 173.51, 0); - data.addBar(ZonedDateTime.now().plusDays(15), 173.87, 174.17, 175, 172.96, 0); - data.addBar(ZonedDateTime.now().plusDays(16), 173, 173.17, 172.06, 173.05, 0); - data.addBar(ZonedDateTime.now().plusDays(17), 172.26, 172.28, 170.5, 170.96, 0); - data.addBar(ZonedDateTime.now().plusDays(18), 170.88, 172.34, 170.26, 171.64, 0); - data.addBar(ZonedDateTime.now().plusDays(19), 171.85, 172.07, 169.34, 170.01, 0); - data.addBar(ZonedDateTime.now().plusDays(20), 170.75, 172.56, 170.36, 172.52, 0); // FB, daily, 9.19.'17 + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("Aroon data").build(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(1)) + .openPrice(168.28) + .highPrice(169.87) + .lowPrice(167.15) + .closePrice(169.64) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(2)) + .openPrice(168.84) + .highPrice(169.36) + .lowPrice(168.20) + .closePrice(168.71) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(3)) + .openPrice(168.88) + .highPrice(169.29) + .lowPrice(166.41) + .closePrice(167.74) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(4)) + .openPrice(168) + .highPrice(168.38) + .lowPrice(166.18) + .closePrice(166.32) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(5)) + .openPrice(166.89) + .highPrice(167.70) + .lowPrice(166.33) + .closePrice(167.24) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(6)) + .openPrice(165.25) + .highPrice(168.43) + .lowPrice(165.00) + .closePrice(168.05) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(7)) + .openPrice(168.17) + .highPrice(170.18) + .lowPrice(167.63) + .closePrice(169.92) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(8)) + .highPrice(170.42) + .lowPrice(172.15) + .closePrice(170.06) + .lowPrice(171.97) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(9)) + .openPrice(172.41) + .highPrice(172.92) + .lowPrice(171.31) + .closePrice(172.02) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(10)) + .openPrice(171.2) + .highPrice(172.39) + .lowPrice(169.55) + .closePrice(170.72) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(11)) + .openPrice(170.91) + .highPrice(172.48) + .lowPrice(169.57) + .closePrice(172.09) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(12)) + .openPrice(171.80) + .highPrice(173.31) + .lowPrice(170.27) + .closePrice(173.21) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(13)) + .openPrice(173.09) + .highPrice(173.49) + .lowPrice(170.80) + .closePrice(170.95) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(14)) + .openPrice(172.41) + .highPrice(173.89) + .lowPrice(172.20) + .closePrice(173.51) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(15)) + .openPrice(173.87) + .highPrice(174.17) + .lowPrice(175.00) + .closePrice(172.96) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(16)) + .openPrice(173.00) + .highPrice(173.17) + .lowPrice(172.06) + .closePrice(173.05) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(17)) + .openPrice(172.26) + .highPrice(172.28) + .lowPrice(170.50) + .closePrice(170.96) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(18)) + .openPrice(170.88) + .highPrice(172.34) + .lowPrice(170.26) + .closePrice(171.64) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(19)) + .openPrice(171.85) + .highPrice(172.07) + .lowPrice(169.34) + .closePrice(170.01) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(20)) + .openPrice(170.75) + .highPrice(172.56) + .lowPrice(170.36) + .closePrice(172.52) + .volume(0) + .add(); // FB, daily, 9.19.'17 } @Test public void upDownAndHigh() { - AroonDownIndicator arronDownIndicator = new AroonDownIndicator(data, 5); + var arronDownIndicator = new AroonDownIndicator(data, 5); assertNumEquals(80, arronDownIndicator.getValue(19)); assertNumEquals(100, arronDownIndicator.getValue(18)); assertNumEquals(100, arronDownIndicator.getValue(17)); @@ -94,9 +234,9 @@ public void upDownAndHigh() { @Test public void onlyNaNValues() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("NaN test").build(); + BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("NaN test").build(); for (long i = 0; i <= 1000; i++) { - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); + series.barBuilder().openPrice(NaN).closePrice(NaN).highPrice(NaN).lowPrice(NaN).volume(NaN).add(); } AroonDownIndicator aroonDownIndicator = new AroonDownIndicator(series, 5); @@ -107,22 +247,22 @@ public void onlyNaNValues() { @Test public void naNValuesInIntervall() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("NaN test").build(); + BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("NaN test").build(); for (long i = 10; i >= 0; i--) { // (10, NaN, 9, NaN, 8, NaN, 7, NaN) - Num lowPrice = i % 2 == 0 ? series.numOf(i) : NaN; - series.addBar(ZonedDateTime.now().plusDays(10 - i), NaN, NaN, lowPrice, NaN, NaN); + Num lowPrice = i % 2 == 0 ? series.numFactory().numOf(i) : NaN; + series.barBuilder().lowPrice(lowPrice).add(); } - series.addBar(ZonedDateTime.now().plusDays(11), NaN, NaN, series.numOf(10), NaN, NaN); + series.barBuilder().lowPrice(numOf(10d)).add(); - AroonDownIndicator aroonDownIndicator = new AroonDownIndicator(series, 5); + var aroonDownIndicator = new AroonDownIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0 && i < 11) { assertEquals(NaN.toString(), aroonDownIndicator.getValue(i).toString()); } else if (i < 11) - assertNumEquals(series.numOf(100).toString(), aroonDownIndicator.getValue(i)); + assertNumEquals(series.numFactory().hundred().toString(), aroonDownIndicator.getValue(i)); else - assertNumEquals(series.numOf(80).toString(), aroonDownIndicator.getValue(i)); + assertNumEquals(series.numFactory().numOf(80).toString(), aroonDownIndicator.getValue(i)); } } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonFacadeTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonFacadeTest.java index 7e1cfcc7d..5869e4f35 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonFacadeTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonFacadeTest.java @@ -27,48 +27,189 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.numeric.NumericIndicator; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AroonFacadeTest extends AbstractIndicatorTest, Num> { private BaseBarSeries data; - public AroonFacadeTest(Function numFunction) { - super(numFunction); + public AroonFacadeTest(NumFactory numFactory) { + super(numFactory); } @Before public void init() { - data = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("Aroon data").build(); - data.addBar(ZonedDateTime.now().plusDays(1), 168.28, 169.87, 167.15, 169.64, 0); - data.addBar(ZonedDateTime.now().plusDays(2), 168.84, 169.36, 168.2, 168.71, 0); - data.addBar(ZonedDateTime.now().plusDays(3), 168.88, 169.29, 166.41, 167.74, 0); - data.addBar(ZonedDateTime.now().plusDays(4), 168, 168.38, 166.18, 166.32, 0); - data.addBar(ZonedDateTime.now().plusDays(5), 166.89, 167.7, 166.33, 167.24, 0); - data.addBar(ZonedDateTime.now().plusDays(6), 165.25, 168.43, 165, 168.05, 0); - data.addBar(ZonedDateTime.now().plusDays(7), 168.17, 170.18, 167.63, 169.92, 0); - data.addBar(ZonedDateTime.now().plusDays(8), 170.42, 172.15, 170.06, 171.97, 0); - data.addBar(ZonedDateTime.now().plusDays(9), 172.41, 172.92, 171.31, 172.02, 0); - data.addBar(ZonedDateTime.now().plusDays(10), 171.2, 172.39, 169.55, 170.72, 0); - data.addBar(ZonedDateTime.now().plusDays(11), 170.91, 172.48, 169.57, 172.09, 0); - data.addBar(ZonedDateTime.now().plusDays(12), 171.8, 173.31, 170.27, 173.21, 0); - data.addBar(ZonedDateTime.now().plusDays(13), 173.09, 173.49, 170.8, 170.95, 0); - data.addBar(ZonedDateTime.now().plusDays(14), 172.41, 173.89, 172.2, 173.51, 0); - data.addBar(ZonedDateTime.now().plusDays(15), 173.87, 174.17, 175, 172.96, 0); - data.addBar(ZonedDateTime.now().plusDays(16), 173, 173.17, 172.06, 173.05, 0); - data.addBar(ZonedDateTime.now().plusDays(17), 172.26, 172.28, 170.5, 170.96, 0); - data.addBar(ZonedDateTime.now().plusDays(18), 170.88, 172.34, 170.26, 171.64, 0); - data.addBar(ZonedDateTime.now().plusDays(19), 171.85, 172.07, 169.34, 170.01, 0); - data.addBar(ZonedDateTime.now().plusDays(20), 170.75, 172.56, 170.36, 172.52, 0); // FB, daily, 9.19.'17 + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("Aroon data").build(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(1)) + .openPrice(168.28) + .closePrice(169.87) + .highPrice(167.15) + .lowPrice(169.64) + .volume(0) + .add(); + + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(2)) + .openPrice(168.84) + .closePrice(169.36) + .highPrice(168.20) + .lowPrice(168.71) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(3)) + .openPrice(168.88) + .closePrice(169.29) + .highPrice(166.41) + .lowPrice(167.74) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(4)) + .openPrice(168.00) + .closePrice(168.38) + .highPrice(166.18) + .lowPrice(166.32) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(5)) + .openPrice(166.89) + .closePrice(167.70) + .highPrice(166.33) + .lowPrice(167.24) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(6)) + .openPrice(165.25) + .closePrice(168.43) + .highPrice(165) + .lowPrice(168.05) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(7)) + .openPrice(168.17) + .closePrice(170.18) + .highPrice(167.63) + .lowPrice(169.92) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(8)) + .openPrice(170.42) + .closePrice(172.15) + .highPrice(170.06) + .lowPrice(171.97) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(9)) + .openPrice(172.41) + .closePrice(172.92) + .highPrice(171.31) + .lowPrice(172.02) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(10)) + .openPrice(171.2) + .closePrice(172.39) + .highPrice(169.55) + .lowPrice(170.72) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(11)) + .openPrice(170.91) + .closePrice(172.48) + .highPrice(169.57) + .lowPrice(172.09) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(12)) + .openPrice(171.8) + .closePrice(173.31) + .highPrice(170.27) + .lowPrice(173.21) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(13)) + .openPrice(173.09) + .closePrice(173.49) + .highPrice(170.8) + .lowPrice(170.95) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(14)) + .openPrice(172.41) + .closePrice(173.89) + .highPrice(172.2) + .lowPrice(173.51) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(15)) + .openPrice(173.87) + .closePrice(174.17) + .highPrice(175) + .lowPrice(96) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(16)) + .openPrice(173) + .closePrice(173.17) + .highPrice(172.06) + .lowPrice(173.05) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(17)) + .openPrice(172.26) + .closePrice(172.28) + .highPrice(170.5) + .lowPrice(170.96) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(18)) + .openPrice(170.88) + .closePrice(172.34) + .highPrice(170.26) + .lowPrice(171.64) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(19)) + .openPrice(171.85) + .closePrice(172.07) + .highPrice(169.34) + .lowPrice(170.01) + .volume(0) + .add(); + data.barBuilder() + .endTime(ZonedDateTime.now().plusDays(20)) + .openPrice(170.75) + .closePrice(172.56) + .highPrice(170.36) + .lowPrice(172.52) + .volume(0) + .add(); // FB, daily, 9.19.'17 } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonOscillatorIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonOscillatorIndicatorTest.java index fc9882358..85bd35fd5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonOscillatorIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonOscillatorIndicatorTest.java @@ -35,7 +35,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class AroonOscillatorIndicatorTest { private BarSeries data; @@ -205,19 +205,26 @@ public void init() { + "2017/01/03,116.8600,20635600.0000,116.0300,117.8400,115.5100\n"; String[] dataLine = rawData.split("\n"); - data = new BaseBarSeries("FB_daily"); - DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd", Locale.getDefault()); + data = new MockBarSeriesBuilder().withName("FB_daily").build(); + var dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd", Locale.getDefault()); for (int i = dataLine.length - 1; i >= 0; i--) { String[] tickData = dataLine[i].split(","); ZonedDateTime date = LocalDate.parse(tickData[0], dtf).atStartOfDay(ZoneId.systemDefault()); - data.addBar(date, tickData[3], tickData[4], tickData[5], tickData[1], tickData[2]); + data.barBuilder() + .endTime(date) + .openPrice(tickData[3]) + .highPrice(tickData[4]) + .lowPrice(tickData[5]) + .closePrice(tickData[1]) + .volume(tickData[2]) + .add(); } } @Test public void test() { - AroonOscillatorIndicator aroonOscillator = new AroonOscillatorIndicator(data, 25); + var aroonOscillator = new AroonOscillatorIndicator(data, 25); assertNotNull(aroonOscillator.getAroonUpIndicator()); assertNotNull(aroonOscillator.getAroonDownIndicator()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonUpIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonUpIndicatorTest.java index dfbaa6e3d..12b8b60ee 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonUpIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonUpIndicatorTest.java @@ -32,7 +32,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; public class AroonUpIndicatorTest { @@ -41,33 +41,35 @@ public class AroonUpIndicatorTest { @Before public void init() { - data = new BaseBarSeries(); - data.addBar(ZonedDateTime.now().plusDays(1), 168.28, 169.87, 167.15, 169.64, 0); - data.addBar(ZonedDateTime.now().plusDays(2), 168.84, 169.36, 168.2, 168.71, 0); - data.addBar(ZonedDateTime.now().plusDays(3), 168.88, 169.29, 166.41, 167.74, 0); - data.addBar(ZonedDateTime.now().plusDays(4), 168, 168.38, 166.18, 166.32, 0); - data.addBar(ZonedDateTime.now().plusDays(5), 166.89, 167.7, 166.33, 167.24, 0); - data.addBar(ZonedDateTime.now().plusDays(6), 165.25, 168.43, 165, 168.05, 0); - data.addBar(ZonedDateTime.now().plusDays(7), 168.17, 170.18, 167.63, 169.92, 0); - data.addBar(ZonedDateTime.now().plusDays(8), 170.42, 172.15, 170.06, 171.97, 0); - data.addBar(ZonedDateTime.now().plusDays(9), 172.41, 172.92, 171.31, 172.02, 0); - data.addBar(ZonedDateTime.now().plusDays(10), 171.2, 172.39, 169.55, 170.72, 0); - data.addBar(ZonedDateTime.now().plusDays(11), 170.91, 172.48, 169.57, 172.09, 0); - data.addBar(ZonedDateTime.now().plusDays(12), 171.8, 173.31, 170.27, 173.21, 0); - data.addBar(ZonedDateTime.now().plusDays(13), 173.09, 173.49, 170.8, 170.95, 0); - data.addBar(ZonedDateTime.now().plusDays(14), 172.41, 173.89, 172.2, 173.51, 0); - data.addBar(ZonedDateTime.now().plusDays(15), 173.87, 174.17, 175, 172.96, 0); - data.addBar(ZonedDateTime.now().plusDays(16), 173, 173.17, 172.06, 173.05, 0); - data.addBar(ZonedDateTime.now().plusDays(17), 172.26, 172.28, 170.5, 170.96, 0); - data.addBar(ZonedDateTime.now().plusDays(18), 170.88, 172.34, 170.26, 171.64, 0); - data.addBar(ZonedDateTime.now().plusDays(19), 171.85, 172.07, 169.34, 170.01, 0); - data.addBar(ZonedDateTime.now().plusDays(20), 170.75, 172.56, 170.36, 172.52, 0); // FB, daily, 9.19.'17 + data = new MockBarSeriesBuilder().build(); + data.barBuilder().openPrice(168.28).highPrice(169.87).lowPrice(167.15).closePrice(169.64).volume(0).add(); + data.barBuilder().openPrice(168.84).highPrice(169.36).lowPrice(168.20).closePrice(168.71).volume(0).add(); + data.barBuilder().openPrice(168.88).highPrice(169.29).lowPrice(166.41).closePrice(167.74).volume(0).add(); + data.barBuilder().openPrice(168.00).highPrice(168.38).lowPrice(166.18).closePrice(166.32).volume(0).add(); + data.barBuilder().openPrice(166.89).highPrice(167.70).lowPrice(166.33).closePrice(167.24).volume(0).add(); + data.barBuilder().openPrice(165.25).highPrice(168.43).lowPrice(165.00).closePrice(168.05).volume(0).add(); + data.barBuilder().openPrice(168.17).highPrice(170.18).lowPrice(167.63).closePrice(169.92).volume(0).add(); + data.barBuilder().openPrice(170.42).highPrice(172.15).lowPrice(170.06).closePrice(171.97).volume(0).add(); + data.barBuilder().openPrice(172.41).highPrice(172.92).lowPrice(171.31).closePrice(172.02).volume(0).add(); + data.barBuilder().openPrice(171.20).highPrice(172.39).lowPrice(169.55).closePrice(170.72).volume(0).add(); + data.barBuilder().openPrice(170.91).highPrice(172.48).lowPrice(169.57).closePrice(172.09).volume(0).add(); + data.barBuilder().openPrice(171.80).highPrice(173.31).lowPrice(170.27).closePrice(173.21).volume(0).add(); + data.barBuilder().openPrice(173.09).highPrice(173.49).lowPrice(170.80).closePrice(170.95).volume(0).add(); + data.barBuilder().openPrice(172.41).highPrice(173.89).lowPrice(172.20).closePrice(173.51).volume(0).add(); + data.barBuilder().openPrice(173.87).highPrice(174.17).lowPrice(175.00).closePrice(172.96).volume(0).add(); + data.barBuilder().openPrice(173.00).highPrice(173.17).lowPrice(172.06).closePrice(173.05).volume(0).add(); + data.barBuilder().openPrice(172.26).highPrice(172.28).lowPrice(170.50).closePrice(170.96).volume(0).add(); + data.barBuilder().openPrice(170.88).highPrice(172.34).lowPrice(170.26).closePrice(171.64).volume(0).add(); + data.barBuilder().openPrice(171.85).highPrice(172.07).lowPrice(169.34).closePrice(170.01).volume(0).add(); + data.barBuilder().openPrice(170.75).highPrice(172.56).lowPrice(170.36).closePrice(172.52).volume(0).add(); // FB, + // daily, + // 9.19.'17 } @Test public void upAndSlowDown() { - AroonUpIndicator arronUp = new AroonUpIndicator(data, 5); + var arronUp = new AroonUpIndicator(data, 5); assertNumEquals(0, arronUp.getValue(19)); assertNumEquals(20, arronUp.getValue(18)); assertNumEquals(40, arronUp.getValue(17)); @@ -88,12 +90,19 @@ public void upAndSlowDown() { @Test public void onlyNaNValues() { - BaseBarSeries series = new BaseBarSeries("NaN test"); + var series = new MockBarSeriesBuilder().withName("NaN test").build(); for (long i = 0; i <= 1000; i++) { - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); + series.barBuilder() + .endTime(ZonedDateTime.now().plusDays(i)) + .openPrice(NaN) + .closePrice(NaN) + .highPrice(NaN) + .lowPrice(NaN) + .volume(NaN) + .add(); } - AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); + var aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } @@ -101,18 +110,25 @@ public void onlyNaNValues() { @Test public void naNValuesInInterval() { - BaseBarSeries series = new BaseBarSeries("NaN test"); + var series = new MockBarSeriesBuilder().withName("NaN test").build(); for (long i = 0; i <= 10; i++) { // (0, NaN, 2, NaN, 4, NaN, 6, NaN, 8, ...) - Num highPrice = i % 2 == 0 ? series.numOf(i) : NaN; - series.addBar(ZonedDateTime.now().plusDays(i), NaN, highPrice, NaN, NaN, NaN); + Num highPrice = i % 2 == 0 ? series.numFactory().numOf(i) : NaN; + series.barBuilder() + .endTime(ZonedDateTime.now().plusDays(i)) + .openPrice(NaN) + .closePrice(NaN) + .highPrice(highPrice) + .lowPrice(NaN) + .volume(NaN) + .add(); } - AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); + var aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } else { - assertNumEquals(aroonUpIndicator.getValue(i).toString(), series.numOf(100)); + assertNumEquals(aroonUpIndicator.getValue(i).toString(), series.numFactory().numOf(100)); } } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandFacadeTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandFacadeTest.java index 340e7fb85..34ffe3fa9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandFacadeTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandFacadeTest.java @@ -26,29 +26,28 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.OpenPriceIndicator; -import org.ta4j.core.indicators.numeric.NumericIndicator; import org.ta4j.core.indicators.statistics.StandardDeviationIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BollingerBandFacadeTest extends AbstractIndicatorTest, Num> { - public BollingerBandFacadeTest(Function numFunction) { - super(numFunction); + public BollingerBandFacadeTest(NumFactory numFactory) { + super(numFactory); } @Test public void testCreation() { - final BarSeries data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + final var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); final int barCount = 3; final BollingerBandFacade bollingerBandFacade = new BollingerBandFacade(data, barCount, 2); @@ -65,26 +64,27 @@ public void testCreation() { @Test public void testNumericFacadesSameAsDefaultIndicators() { - final BarSeries data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); - final ClosePriceIndicator closePriceIndicator = new ClosePriceIndicator(data); + final var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); + final var closePriceIndicator = new ClosePriceIndicator(data); final int barCount = 3; - final Indicator sma = new SMAIndicator(closePriceIndicator, 3); + final var sma = new SMAIndicator(closePriceIndicator, 3); - final BollingerBandsMiddleIndicator middleBB = new BollingerBandsMiddleIndicator(sma); - final StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePriceIndicator, - barCount); - final BollingerBandsLowerIndicator lowerBB = new BollingerBandsLowerIndicator(middleBB, standardDeviation); - final BollingerBandsUpperIndicator upperBB = new BollingerBandsUpperIndicator(middleBB, standardDeviation); - final PercentBIndicator pcb = new PercentBIndicator(new ClosePriceIndicator(data), 5, 2); - final BollingerBandWidthIndicator widthBB = new BollingerBandWidthIndicator(upperBB, middleBB, lowerBB); + final var middleBB = new BollingerBandsMiddleIndicator(sma); + final var standardDeviation = new StandardDeviationIndicator(closePriceIndicator, barCount); + final var lowerBB = new BollingerBandsLowerIndicator(middleBB, standardDeviation); + final var upperBB = new BollingerBandsUpperIndicator(middleBB, standardDeviation); + final var pcb = new PercentBIndicator(new ClosePriceIndicator(data), 5, 2); + final var widthBB = new BollingerBandWidthIndicator(upperBB, middleBB, lowerBB); - final BollingerBandFacade bollingerBandFacade = new BollingerBandFacade(data, barCount, 2); - final NumericIndicator middleBBNumeric = bollingerBandFacade.middle(); - final NumericIndicator lowerBBNumeric = bollingerBandFacade.lower(); - final NumericIndicator upperBBNumeric = bollingerBandFacade.upper(); - final NumericIndicator widthBBNumeric = bollingerBandFacade.bandwidth(); + final var bollingerBandFacade = new BollingerBandFacade(data, barCount, 2); + final var middleBBNumeric = bollingerBandFacade.middle(); + final var lowerBBNumeric = bollingerBandFacade.lower(); + final var upperBBNumeric = bollingerBandFacade.upper(); + final var widthBBNumeric = bollingerBandFacade.bandwidth(); - final NumericIndicator pcbNumeric = new BollingerBandFacade(data, 5, 2).percentB(); + final var pcbNumeric = new BollingerBandFacade(data, 5, 2).percentB(); for (int i = data.getBeginIndex(); i <= data.getEndIndex(); i++) { assertNumEquals(pcb.getValue(i), pcbNumeric.getValue(i)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicatorTest.java index 32edf4756..3e63e02c4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandWidthIndicatorTest.java @@ -25,45 +25,44 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.statistics.StandardDeviationIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BollingerBandWidthIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePrice; - public BollingerBandWidthIndicatorTest(Function numFunction) { - super(numFunction); + public BollingerBandWidthIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 10, 12, 15, 14, 17, 20, 21, 20, 20, 19, 20, 17, 12, 12, 9, 8, 9, - 10, 9, 10); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(10, 12, 15, 14, 17, 20, 21, 20, 20, 19, 20, 17, 12, 12, 9, 8, 9, 10, 9, 10) + .build(); closePrice = new ClosePriceIndicator(data); } @Test public void bollingerBandWidthUsingSMAAndStandardDeviation() { - SMAIndicator sma = new SMAIndicator(closePrice, 5); - StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePrice, 5); + var sma = new SMAIndicator(closePrice, 5); + var standardDeviation = new StandardDeviationIndicator(closePrice, 5); - BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); - BollingerBandsUpperIndicator bbuSMA = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation); - BollingerBandsLowerIndicator bblSMA = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation); + var bbmSMA = new BollingerBandsMiddleIndicator(sma); + var bbuSMA = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation); + var bblSMA = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation); - BollingerBandWidthIndicator bandwidth = new BollingerBandWidthIndicator(bbuSMA, bbmSMA, bblSMA); + var bandwidth = new BollingerBandWidthIndicator(bbuSMA, bbmSMA, bblSMA); assertNumEquals(0.0, bandwidth.getValue(0)); assertNumEquals(36.3636, bandwidth.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicatorTest.java index e2725ca93..3bf4d4d07 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsLowerIndicatorTest.java @@ -25,18 +25,16 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.statistics.StandardDeviationIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BollingerBandsLowerIndicatorTest extends AbstractIndicatorTest, Num> { @@ -46,13 +44,15 @@ public class BollingerBandsLowerIndicatorTest extends AbstractIndicatorTest numFunction) { - super(null, numFunction); + public BollingerBandsLowerIndicatorTest(NumFactory numFactory) { + super(null, numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); barCount = 3; closePrice = new ClosePriceIndicator(data); sma = new SMAIndicator(closePrice, barCount); @@ -61,9 +61,9 @@ public void setUp() { @Test public void bollingerBandsLowerUsingSMAAndStandardDeviation() { - BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); - StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePrice, barCount); - BollingerBandsLowerIndicator bblSMA = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation); + var bbmSMA = new BollingerBandsMiddleIndicator(sma); + var standardDeviation = new StandardDeviationIndicator(closePrice, barCount); + var bblSMA = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation); assertNumEquals(2, bblSMA.getK()); @@ -75,8 +75,7 @@ public void bollingerBandsLowerUsingSMAAndStandardDeviation() { assertNumEquals(2.7239, bblSMA.getValue(5)); assertNumEquals(2.367, bblSMA.getValue(6)); - BollingerBandsLowerIndicator bblSMAwithK = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation, - numFunction.apply(1.5)); + var bblSMAwithK = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation, numFactory.numOf(1.5)); assertNumEquals(1.5, bblSMAwithK.getK()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsMiddleIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsMiddleIndicatorTest.java index 061bbf3bc..2bba10f4d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsMiddleIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsMiddleIndicatorTest.java @@ -25,8 +25,6 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -34,25 +32,28 @@ import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BollingerBandsMiddleIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public BollingerBandsMiddleIndicatorTest(Function numFunction) { - super(numFunction); + public BollingerBandsMiddleIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); } @Test public void bollingerBandsMiddleUsingSMA() { - SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(data), 3); - BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); + var sma = new SMAIndicator(new ClosePriceIndicator(data), 3); + var bbmSMA = new BollingerBandsMiddleIndicator(sma); for (int i = 0; i < data.getBarCount(); i++) { assertEquals(sma.getValue(i), bbmSMA.getValue(i)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicatorTest.java index 8b78dad3c..7f6575ed8 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/BollingerBandsUpperIndicatorTest.java @@ -25,8 +25,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -35,8 +33,9 @@ import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.statistics.StandardDeviationIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BollingerBandsUpperIndicatorTest extends AbstractIndicatorTest, Num> { @@ -46,13 +45,15 @@ public class BollingerBandsUpperIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public BollingerBandsUpperIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2); + BarSeries data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2) + .build(); barCount = 3; closePrice = new ClosePriceIndicator(data); sma = new SMAIndicator(closePrice, barCount); @@ -61,9 +62,9 @@ public void setUp() { @Test public void bollingerBandsUpperUsingSMAAndStandardDeviation() { - BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); - StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePrice, barCount); - BollingerBandsUpperIndicator bbuSMA = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation); + var bbmSMA = new BollingerBandsMiddleIndicator(sma); + var standardDeviation = new StandardDeviationIndicator(closePrice, barCount); + var bbuSMA = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation); assertNumEquals(2, bbuSMA.getK()); @@ -79,7 +80,7 @@ public void bollingerBandsUpperUsingSMAAndStandardDeviation() { assertNumEquals(4.2761, bbuSMA.getValue(9)); BollingerBandsUpperIndicator bbuSMAwithK = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation, - numFunction.apply(1.5)); + numFactory.numOf(1.5)); assertNumEquals(1.5, bbuSMAwithK.getK()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/PercentBIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/PercentBIndicatorTest.java index 88a89562d..07b8f060a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/PercentBIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/bollinger/PercentBIndicatorTest.java @@ -26,36 +26,35 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PercentBIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePrice; - public PercentBIndicatorTest(Function numFunction) { - super(numFunction); + public PercentBIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new MockBarSeries(numFunction, 10, 12, 15, 14, 17, 20, 21, 20, 20, 19, 20, 17, 12, 12, 9, 8, 9, - 10, 9, 10); + var data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(10, 12, 15, 14, 17, 20, 21, 20, 20, 19, 20, 17, 12, 12, 9, 8, 9, 10, 9, 10) + .build(); closePrice = new ClosePriceIndicator(data); } @Test public void percentBUsingSMAAndStandardDeviation() { - PercentBIndicator pcb = new PercentBIndicator(closePrice, 5, 2); + var pcb = new PercentBIndicator(closePrice, 5, 2); assertTrue(pcb.getValue(0).isNaN()); assertNumEquals(0.75, pcb.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishEngulfingIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishEngulfingIndicatorTest.java index 75f181f1c..4b37bd50c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishEngulfingIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishEngulfingIndicatorTest.java @@ -26,43 +26,36 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BearishEngulfingIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public BearishEngulfingIndicatorTest(Function numFunction) { - super(numFunction); + public BearishEngulfingIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(21, 15, 22, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(21).closePrice(15).highPrice(22).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - BearishEngulfingIndicator bep = new BearishEngulfingIndicator(series); + var bep = new BearishEngulfingIndicator(series); assertFalse(bep.getValue(0)); assertFalse(bep.getValue(1)); assertTrue(bep.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishHaramiIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishHaramiIndicatorTest.java index 616644ef0..ef5da3553 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishHaramiIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BearishHaramiIndicatorTest.java @@ -26,43 +26,36 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BearishHaramiIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public BearishHaramiIndicatorTest(Function numFunction) { - super(numFunction); + public BearishHaramiIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(15, 18, 19, 14, numFunction)); - bars.add(new MockBar(17, 16, 19, 15, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(15).closePrice(18).highPrice(19).lowPrice(14).add(); + series.barBuilder().openPrice(17).closePrice(16).highPrice(19).lowPrice(15).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - BearishHaramiIndicator bhp = new BearishHaramiIndicator(series); + var bhp = new BearishHaramiIndicator(series); assertFalse(bhp.getValue(0)); assertFalse(bhp.getValue(1)); assertTrue(bhp.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishEngulfingIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishEngulfingIndicatorTest.java index 5d07f4155..a9b73a270 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishEngulfingIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishEngulfingIndicatorTest.java @@ -26,43 +26,36 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BullishEngulfingIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public BullishEngulfingIndicatorTest(Function numFunction) { - super(numFunction); + public BullishEngulfingIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 16, 19, 15, numFunction)); - bars.add(new MockBar(15, 18, 19, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(16).highPrice(19).lowPrice(15).add(); + series.barBuilder().openPrice(15).closePrice(18).highPrice(19).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - BullishEngulfingIndicator bep = new BullishEngulfingIndicator(series); + var bep = new BullishEngulfingIndicator(series); assertFalse(bep.getValue(0)); assertFalse(bep.getValue(1)); assertTrue(bep.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishHaramiIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishHaramiIndicatorTest.java index c6fac793e..897152e34 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishHaramiIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/BullishHaramiIndicatorTest.java @@ -26,43 +26,36 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BullishHaramiIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public BullishHaramiIndicatorTest(Function numFunction) { - super(numFunction); + public BullishHaramiIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(21, 15, 22, 14, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(21).closePrice(15).highPrice(22).lowPrice(14).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - BullishHaramiIndicator bhp = new BullishHaramiIndicator(series); + var bhp = new BullishHaramiIndicator(series); assertFalse(bhp.getValue(0)); assertFalse(bhp.getValue(1)); assertTrue(bhp.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/DojiIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/DojiIndicatorTest.java index 5b8123243..ec6fa10a0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/DojiIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/DojiIndicatorTest.java @@ -26,47 +26,42 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DojiIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public DojiIndicatorTest(Function numFunction) { - super(numFunction); + public DojiIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(19, 19, 22, 16, numFunction)); - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 15.1, 16, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + series.barBuilder().openPrice(19).closePrice(19).highPrice(22).lowPrice(16).add(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(15.1).highPrice(16).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValueAtIndex0() { - DojiIndicator doji = new DojiIndicator(new MockBarSeries(numFunction, 0d), 10, 0.03); + var doji = new DojiIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory).withData(0d).build(), 10, + 0.03); assertTrue(doji.getValue(0)); - doji = new DojiIndicator(new MockBarSeries(numFunction, 1d), 10, 0.03); + doji = new DojiIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1d).build(), 10, 0.03); assertFalse(doji.getValue(0)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/LowerShadowIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/LowerShadowIndicatorTest.java index cfbd0a56d..5f959ddbc 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/LowerShadowIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/LowerShadowIndicatorTest.java @@ -25,38 +25,31 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LowerShadowIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public LowerShadowIndicatorTest(Function numFunction) { - super(numFunction); + public LowerShadowIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 15, 16, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(15).highPrice(16).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/RealBodyIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/RealBodyIndicatorTest.java index 9f5bdba27..3f3b77d7e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/RealBodyIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/RealBodyIndicatorTest.java @@ -25,42 +25,35 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class RealBodyIndicatorTest extends AbstractIndicatorTest { private BarSeries series; - public RealBodyIndicatorTest(Function numFunction) { - super(numFunction); + public RealBodyIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 15, 16, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(15).highPrice(16).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - RealBodyIndicator body = new RealBodyIndicator(series); + var body = new RealBodyIndicator(series); assertNumEquals(8, body.getValue(0)); assertNumEquals(3, body.getValue(1)); assertNumEquals(0, body.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicatorTest.java index cd6600024..7ccb7ee53 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeBlackCrowsIndicatorTest.java @@ -26,46 +26,39 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ThreeBlackCrowsIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public ThreeBlackCrowsIndicatorTest(Function numFunction) { - super(numFunction); + public ThreeBlackCrowsIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(19, 19, 22, 15, numFunction)); - bars.add(new MockBar(10, 18, 20, 8, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(19, 17, 20, 16.9, numFunction)); - bars.add(new MockBar(17.5, 14, 18, 13.9, numFunction)); - bars.add(new MockBar(15, 11, 15, 11, numFunction)); - bars.add(new MockBar(12, 14, 15, 8, numFunction)); - bars.add(new MockBar(13, 16, 16, 11, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(19).closePrice(19).highPrice(22).lowPrice(15.0).add(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(8.0).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17.0).add(); + series.barBuilder().openPrice(19).closePrice(17).highPrice(20).lowPrice(16.9).add(); + series.barBuilder().openPrice(17.5).closePrice(14).highPrice(18).lowPrice(13.9).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(11.0).add(); + series.barBuilder().openPrice(12).closePrice(14).highPrice(15).lowPrice(8.0).add(); + series.barBuilder().openPrice(13).closePrice(16).highPrice(16).lowPrice(11.0).add(); } @Test public void getValue() { - ThreeBlackCrowsIndicator tbc = new ThreeBlackCrowsIndicator(series, 3, 0.1); + var tbc = new ThreeBlackCrowsIndicator(series, 3, 0.1); assertFalse(tbc.getValue(0)); assertFalse(tbc.getValue(1)); assertFalse(tbc.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeWhiteSoldiersIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeWhiteSoldiersIndicatorTest.java index c31b3cc06..b297a19d8 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeWhiteSoldiersIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/ThreeWhiteSoldiersIndicatorTest.java @@ -26,46 +26,39 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ThreeWhiteSoldiersIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public ThreeWhiteSoldiersIndicatorTest(Function numFunction) { - super(numFunction); + public ThreeWhiteSoldiersIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(19, 19, 22, 15, numFunction)); - bars.add(new MockBar(10, 18, 20, 8, numFunction)); - bars.add(new MockBar(17, 16, 21, 15, numFunction)); - bars.add(new MockBar(15.6, 18, 18.1, 14, numFunction)); - bars.add(new MockBar(16, 19.9, 20, 15, numFunction)); - bars.add(new MockBar(16.8, 23, 23, 16.7, numFunction)); - bars.add(new MockBar(17, 25, 25, 17, numFunction)); - bars.add(new MockBar(23, 16.8, 24, 15, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(19.0).closePrice(19.0).highPrice(22.0).lowPrice(15.0).add(); + series.barBuilder().openPrice(10.0).closePrice(18.0).highPrice(20.0).lowPrice(08.0).add(); + series.barBuilder().openPrice(17.0).closePrice(16.0).highPrice(21.0).lowPrice(15.0).add(); + series.barBuilder().openPrice(15.6).closePrice(18.0).highPrice(18.1).lowPrice(14.0).add(); + series.barBuilder().openPrice(16.0).closePrice(19.9).highPrice(20.0).lowPrice(15.0).add(); + series.barBuilder().openPrice(16.8).closePrice(23.0).highPrice(23.0).lowPrice(16.7).add(); + series.barBuilder().openPrice(17.0).closePrice(25.0).highPrice(25.0).lowPrice(17.0).add(); + series.barBuilder().openPrice(23.0).closePrice(16.8).highPrice(24.0).lowPrice(15.0).add(); } @Test public void getValue() { - ThreeWhiteSoldiersIndicator tws = new ThreeWhiteSoldiersIndicator(series, 3, series.numOf(0.1)); + var tws = new ThreeWhiteSoldiersIndicator(series, 3, series.numFactory().numOf(0.1)); assertFalse(tws.getValue(0)); assertFalse(tws.getValue(1)); assertFalse(tws.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/UpperShadowIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/UpperShadowIndicatorTest.java index a5c5d7b56..76e762929 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/UpperShadowIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/candles/UpperShadowIndicatorTest.java @@ -25,42 +25,35 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class UpperShadowIndicatorTest extends AbstractIndicatorTest { private BarSeries series; - public UpperShadowIndicatorTest(Function numFunction) { - super(numFunction); + public UpperShadowIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 15, 16, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(15).highPrice(16).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); } @Test public void getValue() { - UpperShadowIndicator upperShadow = new UpperShadowIndicator(series); + var upperShadow = new UpperShadowIndicator(series); assertNumEquals(2, upperShadow.getValue(0)); assertNumEquals(1, upperShadow.getValue(1)); assertNumEquals(1, upperShadow.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelLowerIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelLowerIndicatorTest.java index ed4386ca4..ced369679 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelLowerIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelLowerIndicatorTest.java @@ -25,54 +25,39 @@ import static org.junit.Assert.assertEquals; -import java.time.Duration; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DonchianChannelLowerIndicatorTest extends AbstractIndicatorTest { private BarSeries series; - public DonchianChannelLowerIndicatorTest(Function numFunction) { - super(numFunction); + public DonchianChannelLowerIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - ZonedDateTime startDateTime = ZonedDateTime.now(); - List bars = new ArrayList<>(); - - bars.add(new BaseBar(Duration.ofHours(1), startDateTime, 100d, 105d, 95d, 100d, 0d, 0, 0, this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(1), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(2), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(3), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(4), 120, 125, 115, 120, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(5), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(6), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(7), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add( - new BaseBar(Duration.ofHours(1), startDateTime.plusHours(8), 100, 105, 95, 100, 0d, 0, 0, this::numOf)); + this.series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withName("DonchianChannelLowerIndicatorTestSeries") + .build(); + + series.barBuilder().openPrice(100d).highPrice(105d).lowPrice(95d).closePrice(100d).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(120).highPrice(125).lowPrice(115).closePrice(120).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(100).highPrice(105).lowPrice(95).closePrice(100).add(); - this.series = new BaseBarSeries("DonchianChannelLowerIndicatorTestSeries", bars); } @After @@ -81,7 +66,7 @@ public void tearDown() { @Test public void testGetValue() { - DonchianChannelLowerIndicator subject = new DonchianChannelLowerIndicator(series, 3); + var subject = new DonchianChannelLowerIndicator(series, 3); assertEquals(numOf(95), subject.getValue(0)); assertEquals(numOf(95), subject.getValue(1)); @@ -96,7 +81,7 @@ public void testGetValue() { @Test public void testGetValueWhenTimePeriodIs1() { - DonchianChannelLowerIndicator subject = new DonchianChannelLowerIndicator(series, 1); + var subject = new DonchianChannelLowerIndicator(series, 1); assertEquals(numOf(95), subject.getValue(0)); assertEquals(numOf(100), subject.getValue(1)); @@ -111,7 +96,7 @@ public void testGetValueWhenTimePeriodIs1() { @Test public void testGetValueWhenTimePeriodExceedsBarCount() { - DonchianChannelLowerIndicator subject = new DonchianChannelLowerIndicator(series, 10); + var subject = new DonchianChannelLowerIndicator(series, 10); assertEquals(numOf(95), subject.getValue(0)); assertEquals(numOf(95), subject.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicatorTest.java index 0b7a1129c..f3621e127 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelMiddleIndicatorTest.java @@ -25,54 +25,39 @@ import static org.junit.Assert.assertEquals; -import java.time.Duration; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DonchianChannelMiddleIndicatorTest extends AbstractIndicatorTest { private BarSeries series; - public DonchianChannelMiddleIndicatorTest(Function numFunction) { - super(numFunction); + public DonchianChannelMiddleIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - ZonedDateTime startDateTime = ZonedDateTime.now(); - List bars = new ArrayList<>(); + this.series = new MockBarSeriesBuilder().withName("DonchianChannelMiddleIndicatorTestSeries") + .withNumFactory(numFactory) + .build(); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime, 100d, 105d, 95d, 100d, 0d, 0, 0, this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(1), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(2), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(3), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(4), 120, 125, 115, 120, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(5), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(6), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(7), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add( - new BaseBar(Duration.ofHours(1), startDateTime.plusHours(8), 100, 105, 95, 100, 0d, 0, 0, this::numOf)); + series.barBuilder().openPrice(100d).highPrice(105d).lowPrice(95d).closePrice(100d).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(120).highPrice(125).lowPrice(115).closePrice(120).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(100).highPrice(105).lowPrice(95).closePrice(100).add(); - this.series = new BaseBarSeries("DonchianChannelMiddleIndicatorTestSeries", bars); } @After @@ -81,7 +66,7 @@ public void tearDown() { @Test public void testGetValue() { - DonchianChannelMiddleIndicator subject = new DonchianChannelMiddleIndicator(series, 3); + var subject = new DonchianChannelMiddleIndicator(series, 3); assertEquals(numOf(100), subject.getValue(0)); assertEquals(numOf(102.5), subject.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelUpperIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelUpperIndicatorTest.java index bf34b1d2f..e5d583531 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelUpperIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/donchian/DonchianChannelUpperIndicatorTest.java @@ -25,54 +25,39 @@ import static org.junit.Assert.assertEquals; -import java.time.Duration; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DonchianChannelUpperIndicatorTest extends AbstractIndicatorTest { private BarSeries series; - public DonchianChannelUpperIndicatorTest(Function numFunction) { - super(numFunction); + public DonchianChannelUpperIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - ZonedDateTime startDateTime = ZonedDateTime.now(); - List bars = new ArrayList<>(); + this.series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withName("DonchianChannelUpperIndicatorTestSeries") + .build(); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime, 100d, 105d, 95d, 100d, 0d, 0, 0, this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(1), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(2), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(3), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(4), 120, 125, 115, 120, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(5), 115, 120, 110, 115, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(6), 110, 115, 105, 110, 0d, 0, 0, - this::numOf)); - bars.add(new BaseBar(Duration.ofHours(1), startDateTime.plusHours(7), 105, 110, 100, 105, 0d, 0, 0, - this::numOf)); - bars.add( - new BaseBar(Duration.ofHours(1), startDateTime.plusHours(8), 100, 105, 95, 100, 0d, 0, 0, this::numOf)); + series.barBuilder().openPrice(100d).highPrice(105d).lowPrice(95d).closePrice(100d).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(120).highPrice(125).lowPrice(115).closePrice(120).add(); + series.barBuilder().openPrice(115).highPrice(120).lowPrice(110).closePrice(115).add(); + series.barBuilder().openPrice(110).highPrice(115).lowPrice(105).closePrice(110).add(); + series.barBuilder().openPrice(105).highPrice(110).lowPrice(100).closePrice(105).add(); + series.barBuilder().openPrice(100).highPrice(105).lowPrice(95).closePrice(100).add(); - this.series = new BaseBarSeries("DonchianChannelUpperIndicatorTestSeries", bars); } @After @@ -81,7 +66,7 @@ public void tearDown() { @Test public void testGetValue() { - DonchianChannelUpperIndicator subject = new DonchianChannelUpperIndicator(series, 3); + var subject = new DonchianChannelUpperIndicator(series, 3); assertEquals(numOf(105), subject.getValue(0)); assertEquals(numOf(110), subject.getValue(1)); @@ -96,7 +81,7 @@ public void testGetValue() { @Test public void testGetValueWhenBarCountIs1() { - DonchianChannelUpperIndicator subject = new DonchianChannelUpperIndicator(series, 1); + var subject = new DonchianChannelUpperIndicator(series, 1); assertEquals(numOf(105), subject.getValue(0)); assertEquals(numOf(110), subject.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/AmountIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/AmountIndicatorTest.java index 71fc687a3..7b7ae9721 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/AmountIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/AmountIndicatorTest.java @@ -25,15 +25,14 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AmountIndicatorTest extends AbstractIndicatorTest, Num> { @@ -41,13 +40,13 @@ public class AmountIndicatorTest extends AbstractIndicatorTest, N BarSeries barSeries; - public AmountIndicatorTest(Function numFunction) { - super(numFunction); + public AmountIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); amountIndicator = new AmountIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/BooleanTransformIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/BooleanTransformIndicatorTest.java index 5150f77e2..52eadd00f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/BooleanTransformIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/BooleanTransformIndicatorTest.java @@ -26,17 +26,16 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.BooleanTransformIndicator.BooleanTransformSimpleType; import org.ta4j.core.indicators.helpers.BooleanTransformIndicator.BooleanTransformType; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BooleanTransformIndicatorTest extends AbstractIndicatorTest, Num> { @@ -53,23 +52,23 @@ public class BooleanTransformIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public BooleanTransformIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - Num FOUR = numFunction.apply(4); - Num minusFOUR = numFunction.apply(-4); - BarSeries series = new BaseBarSeries(); + Num FOUR = numFactory.numOf(4); + Num minusFOUR = numFactory.numOf(-4); + BarSeries series = new MockBarSeriesBuilder().build(); ConstantIndicator constantIndicator = new ConstantIndicator(series, FOUR); transEquals = new BooleanTransformIndicator(constantIndicator, FOUR, BooleanTransformType.equals); - transIsGreaterThan = new BooleanTransformIndicator(constantIndicator, numFunction.apply(3), + transIsGreaterThan = new BooleanTransformIndicator(constantIndicator, numFactory.numOf(3), BooleanTransformType.isGreaterThan); transIsGreaterThanOrEqual = new BooleanTransformIndicator(constantIndicator, FOUR, BooleanTransformType.isGreaterThanOrEqual); - transIsLessThan = new BooleanTransformIndicator(constantIndicator, numFunction.apply(10), + transIsLessThan = new BooleanTransformIndicator(constantIndicator, numFactory.numOf(10), BooleanTransformType.isLessThan); transIsLessThanOrEqual = new BooleanTransformIndicator(constantIndicator, FOUR, BooleanTransformType.isLessThanOrEqual); @@ -82,7 +81,7 @@ public void setUp() { transIsPositive = new BooleanTransformIndicator(constantIndicator, BooleanTransformSimpleType.isPositive); transIsPositiveOrZero = new BooleanTransformIndicator(constantIndicator, BooleanTransformSimpleType.isPositiveOrZero); - transIsZero = new BooleanTransformIndicator(new ConstantIndicator(series, numFunction.apply(0)), + transIsZero = new BooleanTransformIndicator(new ConstantIndicator(series, numFactory.numOf(0)), BooleanTransformSimpleType.isZero); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicatorTest.java index b8c2ed420..7c1fbd06f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CloseLocationValueIndicatorTest.java @@ -25,42 +25,35 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CloseLocationValueIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public CloseLocationValueIndicatorTest(Function numFunction) { - super(numFunction); + public CloseLocationValueIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - // open, close, high, low - bars.add(new MockBar(10, 18, 20, 10, numFunction)); - bars.add(new MockBar(17, 20, 21, 17, numFunction)); - bars.add(new MockBar(15, 15, 16, 14, numFunction)); - bars.add(new MockBar(15, 11, 15, 8, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, numFunction)); - bars.add(new MockBar(11, 12, 12, 10, numFunction)); - bars.add(new MockBar(11, 120, 140, 100, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().build(); + series.barBuilder().openPrice(10).closePrice(18).highPrice(20).lowPrice(10).add(); + series.barBuilder().openPrice(17).closePrice(20).highPrice(21).lowPrice(17).add(); + series.barBuilder().openPrice(15).closePrice(15).highPrice(16).lowPrice(14).add(); + series.barBuilder().openPrice(15).closePrice(11).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).add(); + series.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).add(); + series.barBuilder().openPrice(11).closePrice(120).highPrice(140).lowPrice(100).add(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceDifferenceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceDifferenceIndicatorTest.java index 2c2892a0d..470b37d1f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceDifferenceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceDifferenceIndicatorTest.java @@ -23,18 +23,17 @@ */ package org.ta4j.core.indicators.helpers; +import static junit.framework.TestCase.assertEquals; +import static org.ta4j.core.TestUtils.assertNumEquals; + import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; - -import java.util.function.Function; - -import static junit.framework.TestCase.assertEquals; -import static org.ta4j.core.TestUtils.assertNumEquals; +import org.ta4j.core.num.NumFactory; public class ClosePriceDifferenceIndicatorTest extends AbstractIndicatorTest, Num> { @@ -42,13 +41,13 @@ public class ClosePriceDifferenceIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public ClosePriceDifferenceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); closePriceDifference = new ClosePriceDifferenceIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceIndicatorTest.java index ccbc65b85..f31211cde 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceIndicatorTest.java @@ -25,28 +25,27 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ClosePriceIndicatorTest extends AbstractIndicatorTest, Num> { private ClosePriceIndicator closePrice; BarSeries barSeries; - public ClosePriceIndicatorTest(Function numFunction) { - super(numFunction); + public ClosePriceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); closePrice = new ClosePriceIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceRatioIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceRatioIndicatorTest.java index 83cac3fcc..14f5daefc 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceRatioIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ClosePriceRatioIndicatorTest.java @@ -26,15 +26,14 @@ import static junit.framework.TestCase.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ClosePriceRatioIndicatorTest extends AbstractIndicatorTest, Num> { @@ -42,13 +41,13 @@ public class ClosePriceRatioIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public ClosePriceRatioIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); variationIndicator = new ClosePriceRatioIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CombineIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CombineIndicatorTest.java index 42c9dd441..c92721070 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CombineIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/CombineIndicatorTest.java @@ -30,12 +30,12 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CombineIndicatorTest extends AbstractIndicatorTest, Num> { @@ -46,15 +46,15 @@ public class CombineIndicatorTest extends AbstractIndicatorTest, private CombineIndicator combineMax; private CombineIndicator combineMin; - public CombineIndicatorTest(Function numFunction) { - super(numFunction); + public CombineIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); - ConstantIndicator constantIndicator = new ConstantIndicator<>(series, numOf(4)); - ConstantIndicator constantIndicatorTwo = new ConstantIndicator<>(series, numOf(2)); + BarSeries series = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); + var constantIndicator = new ConstantIndicator<>(series, numOf(4)); + var constantIndicatorTwo = new ConstantIndicator<>(series, numOf(2)); combinePlus = CombineIndicator.plus(constantIndicator, constantIndicatorTwo); combineMinus = CombineIndicator.minus(constantIndicator, constantIndicatorTwo); @@ -79,11 +79,11 @@ public void testDifferenceIndicator() { Function numFunction = DecimalNum::valueOf; - BarSeries series = new BaseBarSeries(); - FixedIndicator mockIndicator = new FixedIndicator(series, numFunction.apply(-2.0), - numFunction.apply(0.00), numFunction.apply(1.00), numFunction.apply(2.53), numFunction.apply(5.87), - numFunction.apply(6.00), numFunction.apply(10.0)); - ConstantIndicator constantIndicator = new ConstantIndicator(series, numFunction.apply(6)); + BarSeries series = new BaseBarSeriesBuilder().build(); + var mockIndicator = new FixedIndicator<>(series, numFunction.apply(-2.0), numFunction.apply(0.00), + numFunction.apply(1.00), numFunction.apply(2.53), numFunction.apply(5.87), numFunction.apply(6.00), + numFunction.apply(10.0)); + var constantIndicator = new ConstantIndicator<>(series, numFunction.apply(6)); CombineIndicator differenceIndicator = CombineIndicator.minus(constantIndicator, mockIndicator); assertNumEquals("8", differenceIndicator.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConstantIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConstantIndicatorTest.java index 938400f2e..894c44da1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConstantIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConstantIndicatorTest.java @@ -27,8 +27,7 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; public class ConstantIndicatorTest { @@ -36,8 +35,8 @@ public class ConstantIndicatorTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - constantIndicator = new ConstantIndicator(series, series.numOf(30.33)); + var series = new MockBarSeriesBuilder().build(); + constantIndicator = new ConstantIndicator<>(series, series.numFactory().numOf(30.33)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicatorTest.java index 42d963cc7..d5ddf5ebb 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/ConvergenceDivergenceIndicatorTest.java @@ -29,10 +29,10 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.ConvergenceDivergenceIndicator.ConvergenceDivergenceStrictType; import org.ta4j.core.indicators.helpers.ConvergenceDivergenceIndicator.ConvergenceDivergenceType; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; public class ConvergenceDivergenceIndicatorTest { @@ -63,7 +63,7 @@ public class ConvergenceDivergenceIndicatorTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); + BarSeries series = new MockBarSeriesBuilder().build(); refPosCon = new FixedDecimalIndicator(series, 1, 2, 3, 4, 5, 8, 3, 2, -2, 1); otherPosCon = new FixedDecimalIndicator(series, 10, 20, 30, 40, 50, 60, 7, 5, 3, 2); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DateTimeIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DateTimeIndicatorTest.java index 8b2f33e62..e1820b0d3 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DateTimeIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DateTimeIndicatorTest.java @@ -27,32 +27,29 @@ import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; -import java.util.Arrays; -import java.util.List; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DateTimeIndicatorTest extends AbstractIndicatorTest, Num> { private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_ZONED_DATE_TIME; - public DateTimeIndicatorTest(Function numFunction) { - super(numFunction); + public DateTimeIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void test() { ZonedDateTime expectedZonedDateTime = ZonedDateTime.parse("2019-09-17T00:04:00-00:00", DATE_TIME_FORMATTER); - List bars = Arrays.asList(new MockBar(expectedZonedDateTime, 1, numFunction)); - BarSeries series = new MockBarSeries(bars); + BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().endTime(expectedZonedDateTime).add(); DateTimeIndicator dateTimeIndicator = new DateTimeIndicator(series, Bar::getEndTime); assertEquals(expectedZonedDateTime, dateTimeIndicator.getValue(0)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicatorTest.java index cc93251fb..e3d54fe70 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/DifferencePercentageIndicatorTest.java @@ -25,28 +25,26 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class DifferencePercentageIndicatorTest extends AbstractIndicatorTest, Num> { private DifferencePercentageIndicator percentageChangeIndicator; - public DifferencePercentageIndicatorTest(Function numFunction) { - super(numFunction); + public DifferencePercentageIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValueWithoutThreshold() { - BarSeries series = new MockBarSeries(numFunction); - FixedIndicator mockIndicator = new FixedIndicator(series, numOf(100), numOf(101), numOf(98.98), - numOf(102.186952), numOf(91.9682568), numOf(100.5213046824), numOf(101.526517729224)); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + var mockIndicator = new FixedIndicator<>(series, numOf(100), numOf(101), numOf(98.98), numOf(102.186952), + numOf(91.9682568), numOf(100.5213046824), numOf(101.526517729224)); percentageChangeIndicator = new DifferencePercentageIndicator(mockIndicator); assertNumEquals(NaN.NaN, percentageChangeIndicator.getValue(0)); @@ -60,10 +58,10 @@ public void getValueWithoutThreshold() { @Test public void getValueWithNumThreshold() { - BarSeries series = new MockBarSeries(numFunction); - FixedIndicator mockIndicator = new FixedIndicator(series, numOf(1000), numOf(1010), numOf(1020), - numOf(1050), numOf(1060.5), numOf(1081.5), numOf(1102.5), numOf(1091.475), numOf(1113.525), - numOf(1036.35), numOf(1067.4405)); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + var mockIndicator = new FixedIndicator<>(series, numOf(1000), numOf(1010), numOf(1020), numOf(1050), + numOf(1060.5), numOf(1081.5), numOf(1102.5), numOf(1091.475), numOf(1113.525), numOf(1036.35), + numOf(1067.4405)); percentageChangeIndicator = new DifferencePercentageIndicator(mockIndicator, numOf(5)); assertNumEquals(NaN.NaN, percentageChangeIndicator.getValue(0)); @@ -81,9 +79,9 @@ public void getValueWithNumThreshold() { @Test public void getValueWithNumberThreshold() { - BarSeries series = new MockBarSeries(numFunction); - FixedIndicator mockIndicator = new FixedIndicator(series, numOf(1000), numOf(1000), numOf(1010), - numOf(1025), numOf(1038.325)); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + var mockIndicator = new FixedIndicator<>(series, numOf(1000), numOf(1000), numOf(1010), numOf(1025), + numOf(1038.325)); percentageChangeIndicator = new DifferencePercentageIndicator(mockIndicator, 1.5); assertNumEquals(NaN.NaN, percentageChangeIndicator.getValue(0)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/FixedIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/FixedIndicatorTest.java index af464b472..31984ee00 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/FixedIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/FixedIndicatorTest.java @@ -28,14 +28,14 @@ import org.junit.Assert; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; public class FixedIndicatorTest { @Test public void getValueOnFixedDecimalIndicator() { - BarSeries series = new BaseBarSeries(); - FixedDecimalIndicator fixedDecimalIndicator = new FixedDecimalIndicator(series, 13.37, 42, -17); + BarSeries series = new BaseBarSeriesBuilder().build(); + var fixedDecimalIndicator = new FixedDecimalIndicator(series, 13.37, 42, -17); assertNumEquals(13.37, fixedDecimalIndicator.getValue(0)); assertNumEquals(42, fixedDecimalIndicator.getValue(1)); assertNumEquals(-17, fixedDecimalIndicator.getValue(2)); @@ -49,9 +49,8 @@ public void getValueOnFixedDecimalIndicator() { @Test public void getValueOnFixedBooleanIndicator() { - BarSeries series = new BaseBarSeries(); - FixedBooleanIndicator fixedBooleanIndicator = new FixedBooleanIndicator(series, false, false, true, false, - true); + BarSeries series = new BaseBarSeriesBuilder().build(); + var fixedBooleanIndicator = new FixedBooleanIndicator(series, false, false, true, false, true); Assert.assertFalse(fixedBooleanIndicator.getValue(0)); Assert.assertFalse(fixedBooleanIndicator.getValue(1)); Assert.assertTrue(fixedBooleanIndicator.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/GainIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/GainIndicatorTest.java index 662b7f13f..94d76aec5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/GainIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/GainIndicatorTest.java @@ -25,32 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class GainIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public GainIndicatorTest(Function numFunction) { - super(numFunction); + public GainIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 7, 4, 3, 3, 5, 3, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 7, 4, 3, 3, 5, 3, 2) + .build(); } @Test public void gainUsingClosePrice() { - GainIndicator gain = new GainIndicator(new ClosePriceIndicator(data)); + var gain = new GainIndicator(new ClosePriceIndicator(data)); assertNumEquals(0, gain.getValue(0)); assertNumEquals(1, gain.getValue(1)); assertNumEquals(1, gain.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighPriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighPriceIndicatorTest.java index 880e82c4f..60e152541 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighPriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighPriceIndicatorTest.java @@ -25,28 +25,27 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class HighPriceIndicatorTest extends AbstractIndicatorTest, Num> { private HighPriceIndicator highPriceIndicator; private BarSeries barSeries; - public HighPriceIndicatorTest(Function numFunction) { - super(numFunction); + public HighPriceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); highPriceIndicator = new HighPriceIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighestValueIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighestValueIndicatorTest.java index fdeeb4e89..3296dc378 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighestValueIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/HighestValueIndicatorTest.java @@ -28,7 +28,6 @@ import static org.ta4j.core.num.NaN.NaN; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; @@ -36,25 +35,28 @@ import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class HighestValueIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public HighestValueIndicatorTest(Function numFunction) { - super(numFunction); + public HighestValueIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 6, 4, 3, 3, 4, 3, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 6, 4, 3, 3, 4, 3, 2) + .build(); } @Test public void highestValueUsingBarCount5UsingClosePrice() { - HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 5); + var highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 5); assertNumEquals("4.0", highestValue.getValue(4)); assertNumEquals("4.0", highestValue.getValue(5)); @@ -69,24 +71,31 @@ public void highestValueUsingBarCount5UsingClosePrice() { @Test public void firstHighestValueIndicatorValueShouldBeEqualsToFirstDataValue() { - HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 5); + var highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 5); assertNumEquals("1.0", highestValue.getValue(0)); } @Test public void highestValueIndicatorWhenBarCountIsGreaterThanIndex() { - HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 500); + var highestValue = new HighestValueIndicator(new ClosePriceIndicator(data), 500); assertNumEquals("6.0", highestValue.getValue(12)); } @Test public void onlyNaNValues() { - BaseBarSeries series = new BaseBarSeries("NaN test"); + BaseBarSeries series = new MockBarSeriesBuilder().withName("NaN test").build(); for (long i = 0; i <= 10000; i++) { - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); + series.barBuilder() + .endTime(ZonedDateTime.now().plusDays(i)) + .openPrice(NaN) + .closePrice(NaN) + .highPrice(NaN) + .lowPrice(NaN) + .volume(NaN) + .add(); } - HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 5); + var highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), highestValue.getValue(i).toString()); } @@ -94,10 +103,17 @@ public void onlyNaNValues() { @Test public void naNValuesInIntervall() { - BaseBarSeries series = new BaseBarSeries("NaN test"); + BaseBarSeries series = new MockBarSeriesBuilder().withName("NaN test").build(); for (long i = 0; i <= 10; i++) { // (0, NaN, 2, NaN, 3, NaN, 4, NaN, 5, ...) - Num closePrice = i % 2 == 0 ? series.numOf(i) : NaN; - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, closePrice, NaN); + Num closePrice = i % 2 == 0 ? series.numFactory().numOf(i) : NaN; + series.barBuilder() + .endTime(ZonedDateTime.now().plusDays(i)) + .openPrice(NaN) + .closePrice(closePrice) + .highPrice(NaN) + .lowPrice(NaN) + .volume(NaN) + .add(); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 2); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LossIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LossIndicatorTest.java index 57007b88d..8ddb20869 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LossIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LossIndicatorTest.java @@ -25,32 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LossIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public LossIndicatorTest(Function numFunction) { - super(numFunction); + public LossIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 7, 4, 3, 3, 5, 3, 2); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 7, 4, 3, 3, 5, 3, 2) + .build(); } @Test public void lossUsingClosePrice() { - LossIndicator loss = new LossIndicator(new ClosePriceIndicator(data)); + var loss = new LossIndicator(new ClosePriceIndicator(data)); assertNumEquals(0, loss.getValue(0)); assertNumEquals(0, loss.getValue(1)); assertNumEquals(0, loss.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowPriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowPriceIndicatorTest.java index 7bdae2023..34e390ec9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowPriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowPriceIndicatorTest.java @@ -25,28 +25,28 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LowPriceIndicatorTest extends AbstractIndicatorTest, Num> { private LowPriceIndicator lowPriceIndicator; private BarSeries barSeries; - public LowPriceIndicatorTest(Function numFunction) { - super(numFunction); + public LowPriceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + ; lowPriceIndicator = new LowPriceIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowestValueIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowestValueIndicatorTest.java index c7eb6cad1..5d8fe01c2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowestValueIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/LowestValueIndicatorTest.java @@ -27,29 +27,29 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import static org.ta4j.core.num.NaN.NaN; -import java.time.ZonedDateTime; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class LowestValueIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public LowestValueIndicatorTest(Function function) { - super(function); + public LowestValueIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 6, 4, 3, 2, 4, 3, 1); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 3, 4, 5, 6, 4, 3, 2, 4, 3, 1) + .build(); } @Test @@ -84,9 +84,9 @@ public void lowestValueIndicatorWhenBarCountIsGreaterThanIndex() { @Test public void onlyNaNValues() { - BaseBarSeries series = new BaseBarSeries("NaN test"); + BaseBarSeries series = new MockBarSeriesBuilder().withName("NaN test").withNumFactory(numFactory).build(); for (long i = 0; i <= 10000; i++) { - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); + series.barBuilder().openPrice(NaN).closePrice(NaN).highPrice(NaN).lowPrice(NaN).add(); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 5); @@ -97,12 +97,12 @@ public void onlyNaNValues() { @Test public void naNValuesInIntervall() { - BaseBarSeries series = new BaseBarSeries("NaN test"); - for (long i = 0; i <= 10; i++) { // (NaN, 1, NaN, 2, NaN, 3, NaN, 4, ...) - series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); + BaseBarSeries series = new MockBarSeriesBuilder().withName("NaN test").withNumFactory(numFactory).build(); + for (long i = 0; i <= 10; i++) { + series.barBuilder().openPrice(NaN).closePrice(NaN).highPrice(NaN).lowPrice(NaN).add(); } - LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 2); + var lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(series.getBar(i - 1).getClosePrice().toString(), lowestValue.getValue(i).toString()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/MedianPriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/MedianPriceIndicatorTest.java index 2bf8b7451..1dc8abb7f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/MedianPriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/MedianPriceIndicatorTest.java @@ -25,45 +25,39 @@ import static junit.framework.TestCase.assertEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MedianPriceIndicatorTest extends AbstractIndicatorTest, Num> { private MedianPriceIndicator average; BarSeries barSeries; - public MedianPriceIndicatorTest(Function numFunction) { + public MedianPriceIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - List bars = new ArrayList(); + this.barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); - bars.add(new MockBar(0, 0, 16, 8, numFunction)); - bars.add(new MockBar(0, 0, 12, 6, numFunction)); - bars.add(new MockBar(0, 0, 18, 14, numFunction)); - bars.add(new MockBar(0, 0, 10, 6, numFunction)); - bars.add(new MockBar(0, 0, 32, 6, numFunction)); - bars.add(new MockBar(0, 0, 2, 2, numFunction)); - bars.add(new MockBar(0, 0, 0, 0, numFunction)); - bars.add(new MockBar(0, 0, 8, 1, numFunction)); - bars.add(new MockBar(0, 0, 83, 32, numFunction)); - bars.add(new MockBar(0, 0, 9, 3, numFunction)); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(16).lowPrice(8).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(12).lowPrice(6).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(18).lowPrice(14).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(10).lowPrice(6).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(32).lowPrice(6).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(2).lowPrice(2).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(0).lowPrice(0).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(8).lowPrice(1).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(83).lowPrice(32).add(); + barSeries.barBuilder().openPrice(0).closePrice(0).highPrice(9).lowPrice(3).add(); - this.barSeries = new MockBarSeries(bars); average = new MedianPriceIndicator(barSeries); } @@ -74,7 +68,7 @@ public void indicatorShouldRetrieveBarClosePrice() { result = barSeries.getBar(i) .getHighPrice() .plus(barSeries.getBar(i).getLowPrice()) - .dividedBy(barSeries.numOf(2)); + .dividedBy(numFactory.numOf(2)); assertEquals(average.getValue(i), result); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumIndicatorTest.java similarity index 84% rename from ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumndicatorTest.java rename to ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumIndicatorTest.java index 48814da9a..dde7f41fd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/NumIndicatorTest.java @@ -25,29 +25,28 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; -public class NumndicatorTest extends AbstractIndicatorTest, Num> { +public class NumIndicatorTest extends AbstractIndicatorTest, Num> { private NumIndicator closePrice; private BarSeries barSeries; - public NumndicatorTest(Function numFunction) { - super(numFunction); + public NumIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); closePrice = new NumIndicator(barSeries, Bar::getClosePrice); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/OpenPriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/OpenPriceIndicatorTest.java index 1d72db271..b509ccb91 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/OpenPriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/OpenPriceIndicatorTest.java @@ -25,28 +25,27 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class OpenPriceIndicatorTest extends AbstractIndicatorTest, Num> { private OpenPriceIndicator openPriceIndicator; BarSeries barSeries; - public OpenPriceIndicatorTest(Function numFunction) { - super(numFunction); + public OpenPriceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); openPriceIndicator = new OpenPriceIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/PreviousValueIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/PreviousValueIndicatorTest.java index 1f5428caa..ebabe01c4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/PreviousValueIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/PreviousValueIndicatorTest.java @@ -32,8 +32,8 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.EMAIndicator; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; public class PreviousValueIndicatorTest { @@ -51,15 +51,22 @@ public class PreviousValueIndicatorTest { @Before public void setUp() { - Random r = new Random(); - this.series = new BaseBarSeries("test"); + var r = new Random(); + this.series = new MockBarSeriesBuilder().withName("test").build(); for (int i = 0; i < 1000; i++) { double open = r.nextDouble(); double close = r.nextDouble(); double max = Math.max(close + r.nextDouble(), open + r.nextDouble()); double min = Math.min(0, Math.min(close - r.nextDouble(), open - r.nextDouble())); ZonedDateTime dateTime = ZonedDateTime.now().minusSeconds(1001 - i); - series.addBar(dateTime, open, close, max, min, i); + series.barBuilder() + .endTime(dateTime) + .openPrice(open) + .closePrice(close) + .highPrice(max) + .lowPrice(min) + .volume(i) + .add(); } this.openPriceIndicator = new OpenPriceIndicator(this.series); @@ -148,4 +155,4 @@ public void testToStringMethodWithNGreaterThen1() { public void testPreviousValueIndicatorWithNonPositiveN() { prevValueIndicator = new PreviousValueIndicator(openPriceIndicator, 0); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/RunningTotalIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/RunningTotalIndicatorTest.java index 5760c0cba..a7830aec5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/RunningTotalIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/RunningTotalIndicatorTest.java @@ -25,26 +25,26 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class RunningTotalIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public RunningTotalIndicatorTest(Function function) { - super((data, params) -> new RunningTotalIndicator(data, (int) params[0]), function); + public RunningTotalIndicatorTest(NumFactory numFactory) { + super((data, params) -> new RunningTotalIndicator(data, (int) params[0]), numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 5); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 4, 5).build(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/SumIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/SumIndicatorTest.java index 9720050c4..2c0c43d47 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/SumIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/SumIndicatorTest.java @@ -28,8 +28,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class SumIndicatorTest { @@ -37,12 +36,14 @@ public class SumIndicatorTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - ConstantIndicator constantIndicator = new ConstantIndicator<>(series, series.numOf(6)); - FixedIndicator mockIndicator = new FixedIndicator(series, series.numOf(-2.0), series.numOf(0.00), - series.numOf(1.00), series.numOf(2.53), series.numOf(5.87), series.numOf(6.00), series.numOf(10.0)); - FixedIndicator mockIndicator2 = new FixedIndicator(series, series.numOf(0), series.numOf(1), - series.numOf(2), series.numOf(3), series.numOf(10), series.numOf(-42), series.numOf(-1337)); + BarSeries series = new MockBarSeriesBuilder().build(); + var constantIndicator = new ConstantIndicator<>(series, series.numFactory().numOf(6)); + var mockIndicator = new FixedIndicator<>(series, series.numFactory().numOf(-2.0), + series.numFactory().numOf(0.00), series.numFactory().numOf(1.00), series.numFactory().numOf(2.53), + series.numFactory().numOf(5.87), series.numFactory().numOf(6.00), series.numFactory().numOf(10.0)); + var mockIndicator2 = new FixedIndicator<>(series, series.numFactory().numOf(0), series.numFactory().numOf(1), + series.numFactory().numOf(2), series.numFactory().numOf(3), series.numFactory().numOf(10), + series.numFactory().numOf(-42), series.numFactory().numOf(-1337)); sumIndicator = new SumIndicator(constantIndicator, mockIndicator, mockIndicator2); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TRIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TRIndicatorTest.java index 1c6ebea5f..7d7c18ac0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TRIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TRIndicatorTest.java @@ -25,33 +25,29 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TRIndicatorTest extends AbstractIndicatorTest, Num> { - public TRIndicatorTest(Function numFunction) { - super(numFunction); + public TRIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValue() { - List bars = new ArrayList(); - bars.add(new MockBar(0, 12, 15, 8, numFunction)); - bars.add(new MockBar(0, 8, 11, 6, numFunction)); - bars.add(new MockBar(0, 15, 17, 14, numFunction)); - bars.add(new MockBar(0, 15, 17, 14, numFunction)); - bars.add(new MockBar(0, 0, 0, 2, numFunction)); - TRIndicator tr = new TRIndicator(new MockBarSeries(bars)); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().openPrice(0).closePrice(12).highPrice(15).lowPrice(8).add(); + series.barBuilder().openPrice(0).closePrice(8).highPrice(11).lowPrice(6).add(); + series.barBuilder().openPrice(0).closePrice(15).highPrice(17).lowPrice(14).add(); + series.barBuilder().openPrice(0).closePrice(15).highPrice(17).lowPrice(14).add(); + series.barBuilder().openPrice(0).closePrice(0).highPrice(0).lowPrice(2).add(); + + var tr = new TRIndicator(series); assertNumEquals(7, tr.getValue(0)); assertNumEquals(6, tr.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TradeCountIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TradeCountIndicatorTest.java index d2420bb1a..5d19e2b84 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TradeCountIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TradeCountIndicatorTest.java @@ -25,28 +25,27 @@ import static org.junit.Assert.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TradeCountIndicatorTest extends AbstractIndicatorTest, Num> { private TradeCountIndicator tradeIndicator; BarSeries barSeries; - public TradeCountIndicatorTest(Function numFunction) { - super(numFunction); + public TradeCountIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); tradeIndicator = new TradeCountIndicator(barSeries); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TransformIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TransformIndicatorTest.java index 13971b25e..bf1b8c613 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TransformIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TransformIndicatorTest.java @@ -25,8 +25,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -34,6 +32,7 @@ import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TransformIndicatorTest extends AbstractIndicatorTest, Num> { @@ -49,13 +48,13 @@ public class TransformIndicatorTest extends AbstractIndicatorTest private TransformIndicator transSqrt; private TransformIndicator transLog; - public TransformIndicatorTest(Function numFunction) { - super(numFunction); + public TransformIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + BarSeries series = new BaseBarSeriesBuilder().withNumFactory(numFactory).build(); ConstantIndicator constantIndicator = new ConstantIndicator<>(series, numOf(4)); transPlus = TransformIndicator.plus(constantIndicator, 10); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicatorTest.java index 2aca7dec4..4abb016c4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/TypicalPriceIndicatorTest.java @@ -25,16 +25,15 @@ import static junit.framework.TestCase.assertEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class TypicalPriceIndicatorTest extends AbstractIndicatorTest, Num> { @@ -42,13 +41,13 @@ public class TypicalPriceIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public TypicalPriceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - barSeries = new MockBarSeries(numFunction); + barSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); typicalPriceIndicator = new TypicalPriceIndicator(barSeries); } @@ -56,10 +55,7 @@ public void setUp() { public void indicatorShouldRetrieveBarHighPrice() { for (int i = 0; i < 10; i++) { Bar bar = barSeries.getBar(i); - Num typicalPrice = bar.getHighPrice() - .plus(bar.getLowPrice()) - .plus(bar.getClosePrice()) - .dividedBy(barSeries.numOf(3)); + Num typicalPrice = bar.getHighPrice().plus(bar.getLowPrice()).plus(bar.getClosePrice()).dividedBy(numOf(3)); assertEquals(typicalPrice, typicalPriceIndicator.getValue(i)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/UnstableIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/UnstableIndicatorTest.java index 40f20dcef..3fe0c6e62 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/UnstableIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/UnstableIndicatorTest.java @@ -26,30 +26,29 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class UnstableIndicatorTest extends AbstractIndicatorTest, Num> { private int unstableBars; private UnstableIndicator unstableIndicator; - public UnstableIndicatorTest(Function numFunction) { - super(numFunction); + public UnstableIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { unstableBars = 5; - unstableIndicator = new UnstableIndicator(new ClosePriceIndicator(new MockBarSeries(numFunction)), - unstableBars); + unstableIndicator = new UnstableIndicator(new ClosePriceIndicator( + new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build()), unstableBars); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/VolumeIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/VolumeIndicatorTest.java index cce4458aa..2fd6d50ce 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/VolumeIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/helpers/VolumeIndicatorTest.java @@ -26,29 +26,23 @@ import static junit.framework.TestCase.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class VolumeIndicatorTest extends AbstractIndicatorTest, Num> { - public VolumeIndicatorTest(Function numFunction) { - super(numFunction); + public VolumeIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void indicatorShouldRetrieveBarVolume() { - BarSeries series = new MockBarSeries(numFunction); - VolumeIndicator volumeIndicator = new VolumeIndicator(series); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).withDefaultData().build(); + var volumeIndicator = new VolumeIndicator(series); for (int i = 0; i < 10; i++) { assertEquals(volumeIndicator.getValue(i), series.getBar(i).getVolume()); } @@ -56,15 +50,16 @@ public void indicatorShouldRetrieveBarVolume() { @Test public void sumOfVolume() { - List bars = new ArrayList(); - bars.add(new MockBar(0, 10, numFunction)); - bars.add(new MockBar(0, 11, numFunction)); - bars.add(new MockBar(0, 12, numFunction)); - bars.add(new MockBar(0, 13, numFunction)); - bars.add(new MockBar(0, 150, numFunction)); - bars.add(new MockBar(0, 155, numFunction)); - bars.add(new MockBar(0, 160, numFunction)); - VolumeIndicator volumeIndicator = new VolumeIndicator(new MockBarSeries(bars), 3); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(0).volume(10).add(); + series.barBuilder().closePrice(0).volume(11).add(); + series.barBuilder().closePrice(0).volume(12).add(); + series.barBuilder().closePrice(0).volume(13).add(); + series.barBuilder().closePrice(0).volume(150).add(); + series.barBuilder().closePrice(0).volume(155).add(); + series.barBuilder().closePrice(0).volume(160).add(); + + var volumeIndicator = new VolumeIndicator(series, 3); assertNumEquals(10, volumeIndicator.getValue(0)); assertNumEquals(21, volumeIndicator.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuChikouSpanIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuChikouSpanIndicatorTest.java index c8c19abcb..d0c234411 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuChikouSpanIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuChikouSpanIndicatorTest.java @@ -26,39 +26,33 @@ import static java.util.stream.Collectors.toList; import static org.junit.Assert.assertEquals; -import java.util.List; -import java.util.function.Function; import java.util.stream.IntStream; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class IchimokuChikouSpanIndicatorTest extends AbstractIndicatorTest { - public IchimokuChikouSpanIndicatorTest(Function numFunction) { - super(numFunction); - } - - private Bar bar(int i) { - return new MockBar(i, this::numOf); + public IchimokuChikouSpanIndicatorTest(NumFactory numFactory) { + super(numFactory); } private BarSeries barSeries(int count) { - final List bars = IntStream.range(0, count).boxed().map(this::bar).collect(toList()); - return new BaseBarSeries(bars); + return new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(IntStream.range(0, count).mapToDouble(Double::valueOf).boxed().collect(toList())) + .build(); } @Test public void testCalculateWithDefaultParam() { final BarSeries barSeries = barSeries(27); - final IchimokuChikouSpanIndicator indicator = new IchimokuChikouSpanIndicator(barSeries); + final var indicator = new IchimokuChikouSpanIndicator(barSeries); assertEquals(numOf(26), indicator.getValue(0)); assertEquals(NaN.NaN, indicator.getValue(1)); @@ -93,7 +87,7 @@ public void testCalculateWithDefaultParam() { public void testCalculateWithSpecifiedValue() { final BarSeries barSeries = barSeries(11); - final IchimokuChikouSpanIndicator indicator = new IchimokuChikouSpanIndicator(barSeries, 3); + final var indicator = new IchimokuChikouSpanIndicator(barSeries, 3); assertEquals(numOf(3), indicator.getValue(0)); assertEquals(numOf(4), indicator.getValue(1)); @@ -108,4 +102,4 @@ public void testCalculateWithSpecifiedValue() { assertEquals(NaN.NaN, indicator.getValue(10)); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuIndicatorTest.java index b2ed0f172..2070f0adb 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/ichimoku/IchimokuIndicatorTest.java @@ -25,61 +25,55 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class IchimokuIndicatorTest extends AbstractIndicatorTest, Num> { protected BarSeries data; - public IchimokuIndicatorTest(Function numFunction) { - super(numFunction); + public IchimokuIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - final List bars = new ArrayList<>(); - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, numFunction)); - bars.add(new MockBar(44.23, 43.95, 44.29, 43.81, numFunction)); - bars.add(new MockBar(43.91, 43.08, 43.99, 43.08, numFunction)); - bars.add(new MockBar(43.07, 43.55, 43.65, 43.06, numFunction)); - bars.add(new MockBar(43.56, 43.95, 43.99, 43.53, numFunction)); - bars.add(new MockBar(43.93, 44.47, 44.58, 43.93, numFunction)); - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).add(); + data.barBuilder().openPrice(44.23).closePrice(43.95).highPrice(44.29).lowPrice(43.81).add(); + data.barBuilder().openPrice(43.91).closePrice(43.08).highPrice(43.99).lowPrice(43.08).add(); + data.barBuilder().openPrice(43.07).closePrice(43.55).highPrice(43.65).lowPrice(43.06).add(); + data.barBuilder().openPrice(43.56).closePrice(43.95).highPrice(43.99).lowPrice(43.53).add(); + data.barBuilder().openPrice(43.93).closePrice(44.47).highPrice(44.58).lowPrice(43.93).add(); } @Test public void ichimoku() { - IchimokuTenkanSenIndicator tenkanSen = new IchimokuTenkanSenIndicator(data, 3); - IchimokuKijunSenIndicator kijunSen = new IchimokuKijunSenIndicator(data, 5); - IchimokuSenkouSpanAIndicator senkouSpanA = new IchimokuSenkouSpanAIndicator(data, tenkanSen, kijunSen, 5); - IchimokuSenkouSpanBIndicator senkouSpanB = new IchimokuSenkouSpanBIndicator(data, 9, 5); + var tenkanSen = new IchimokuTenkanSenIndicator(data, 3); + var kijunSen = new IchimokuKijunSenIndicator(data, 5); + var senkouSpanA = new IchimokuSenkouSpanAIndicator(data, tenkanSen, kijunSen, 5); + var senkouSpanB = new IchimokuSenkouSpanBIndicator(data, 9, 5); final int chikouSpanTimeDelay = 5; IchimokuChikouSpanIndicator chikouSpan = new IchimokuChikouSpanIndicator(data, chikouSpanTimeDelay); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelFacadeTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelFacadeTest.java index 9223386c2..e8f050079 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelFacadeTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelFacadeTest.java @@ -26,83 +26,77 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; +import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.numeric.NumericIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class KeltnerChannelFacadeTest extends AbstractIndicatorTest, Num> { - private MockBarSeries data; + private BarSeries data; - public KeltnerChannelFacadeTest(Function numFunction) { - super(numFunction); + public KeltnerChannelFacadeTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { + data = new MockBarSeriesBuilder().build(); + data.barBuilder().openPrice(11577.43).closePrice(11670.75).highPrice(11711.47).lowPrice(11577.35).add(); + data.barBuilder().openPrice(11670.90).closePrice(11691.18).highPrice(11698.22).lowPrice(11635.74).add(); + data.barBuilder().openPrice(11688.61).closePrice(11722.89).highPrice(11742.68).lowPrice(11652.89).add(); + data.barBuilder().openPrice(11716.93).closePrice(11697.31).highPrice(11736.74).lowPrice(11667.46).add(); + data.barBuilder().openPrice(11696.86).closePrice(11674.76).highPrice(11726.94).lowPrice(11599.68).add(); + data.barBuilder().openPrice(11672.34).closePrice(11637.45).highPrice(11677.33).lowPrice(11573.87).add(); + data.barBuilder().openPrice(11638.51).closePrice(11671.88).highPrice(11704.12).lowPrice(11635.48).add(); + data.barBuilder().openPrice(11673.62).closePrice(11755.44).highPrice(11782.23).lowPrice(11673.62).add(); + data.barBuilder().openPrice(11753.70).closePrice(11731.90).highPrice(11757.25).lowPrice(11700.53).add(); + data.barBuilder().openPrice(11732.13).closePrice(11787.38).highPrice(11794.15).lowPrice(11698.83).add(); + data.barBuilder().openPrice(11783.82).closePrice(11837.93).highPrice(11858.78).lowPrice(11777.99).add(); + data.barBuilder().openPrice(11834.21).closePrice(11825.29).highPrice(11861.24).lowPrice(11798.46).add(); + data.barBuilder().openPrice(11823.70).closePrice(11822.80).highPrice(11845.16).lowPrice(11744.77).add(); + data.barBuilder().openPrice(11822.95).closePrice(11871.84).highPrice(11905.48).lowPrice(11822.80).add(); + data.barBuilder().openPrice(11873.43).closePrice(11980.52).highPrice(11982.94).lowPrice(11867.98).add(); + data.barBuilder().openPrice(11980.52).closePrice(11977.19).highPrice(11985.97).lowPrice(11898.74).add(); + data.barBuilder().openPrice(11978.85).closePrice(11985.44).highPrice(12020.52).lowPrice(11961.83).add(); + data.barBuilder().openPrice(11985.36).closePrice(11989.83).highPrice(12019.53).lowPrice(11971.93).add(); + data.barBuilder().openPrice(11824.39).closePrice(11891.93).highPrice(11891.93).lowPrice(11817.88).add(); + data.barBuilder().openPrice(11892.50).closePrice(12040.16).highPrice(12050.75).lowPrice(11892.50).add(); + data.barBuilder().openPrice(12038.27).closePrice(12041.97).highPrice(12057.91).lowPrice(12018.51).add(); + data.barBuilder().openPrice(12040.68).closePrice(12062.26).highPrice(12080.54).lowPrice(11981.05).add(); + data.barBuilder().openPrice(12061.73).closePrice(12092.15).highPrice(12092.42).lowPrice(12025.78).add(); + data.barBuilder().openPrice(12092.38).closePrice(12161.63).highPrice(12188.76).lowPrice(12092.30).add(); + data.barBuilder().openPrice(12152.70).closePrice(12233.15).highPrice(12238.79).lowPrice(12150.05).add(); + data.barBuilder().openPrice(12229.29).closePrice(12239.89).highPrice(12254.23).lowPrice(12188.19).add(); + data.barBuilder().openPrice(12239.66).closePrice(12229.29).highPrice(12239.66).lowPrice(12156.94).add(); + data.barBuilder().openPrice(12227.78).closePrice(12273.26).highPrice(12285.94).lowPrice(12180.48).add(); + data.barBuilder().openPrice(12266.83).closePrice(12268.19).highPrice(12276.21).lowPrice(12235.91).add(); + data.barBuilder().openPrice(12266.75).closePrice(12226.64).highPrice(12267.66).lowPrice(12193.27).add(); + data.barBuilder().openPrice(12219.79).closePrice(12288.17).highPrice(12303.16).lowPrice(12219.79).add(); + data.barBuilder().openPrice(12287.72).closePrice(12318.14).highPrice(12331.31).lowPrice(12253.24).add(); + data.barBuilder().openPrice(12389.74).closePrice(12212.79).highPrice(12389.82).lowPrice(12176.31).add(); - List bars = new ArrayList<>(); - bars.add(new MockBar(11577.43, 11670.75, 11711.47, 11577.35, numFunction)); - bars.add(new MockBar(11670.90, 11691.18, 11698.22, 11635.74, numFunction)); - bars.add(new MockBar(11688.61, 11722.89, 11742.68, 11652.89, numFunction)); - bars.add(new MockBar(11716.93, 11697.31, 11736.74, 11667.46, numFunction)); - bars.add(new MockBar(11696.86, 11674.76, 11726.94, 11599.68, numFunction)); - bars.add(new MockBar(11672.34, 11637.45, 11677.33, 11573.87, numFunction)); - bars.add(new MockBar(11638.51, 11671.88, 11704.12, 11635.48, numFunction)); - bars.add(new MockBar(11673.62, 11755.44, 11782.23, 11673.62, numFunction)); - bars.add(new MockBar(11753.70, 11731.90, 11757.25, 11700.53, numFunction)); - bars.add(new MockBar(11732.13, 11787.38, 11794.15, 11698.83, numFunction)); - bars.add(new MockBar(11783.82, 11837.93, 11858.78, 11777.99, numFunction)); - bars.add(new MockBar(11834.21, 11825.29, 11861.24, 11798.46, numFunction)); - bars.add(new MockBar(11823.70, 11822.80, 11845.16, 11744.77, numFunction)); - bars.add(new MockBar(11822.95, 11871.84, 11905.48, 11822.80, numFunction)); - bars.add(new MockBar(11873.43, 11980.52, 11982.94, 11867.98, numFunction)); - bars.add(new MockBar(11980.52, 11977.19, 11985.97, 11898.74, numFunction)); - bars.add(new MockBar(11978.85, 11985.44, 12020.52, 11961.83, numFunction)); - bars.add(new MockBar(11985.36, 11989.83, 12019.53, 11971.93, numFunction)); - bars.add(new MockBar(11824.39, 11891.93, 11891.93, 11817.88, numFunction)); - bars.add(new MockBar(11892.50, 12040.16, 12050.75, 11892.50, numFunction)); - bars.add(new MockBar(12038.27, 12041.97, 12057.91, 12018.51, numFunction)); - bars.add(new MockBar(12040.68, 12062.26, 12080.54, 11981.05, numFunction)); - bars.add(new MockBar(12061.73, 12092.15, 12092.42, 12025.78, numFunction)); - bars.add(new MockBar(12092.38, 12161.63, 12188.76, 12092.30, numFunction)); - bars.add(new MockBar(12152.70, 12233.15, 12238.79, 12150.05, numFunction)); - bars.add(new MockBar(12229.29, 12239.89, 12254.23, 12188.19, numFunction)); - bars.add(new MockBar(12239.66, 12229.29, 12239.66, 12156.94, numFunction)); - bars.add(new MockBar(12227.78, 12273.26, 12285.94, 12180.48, numFunction)); - bars.add(new MockBar(12266.83, 12268.19, 12276.21, 12235.91, numFunction)); - bars.add(new MockBar(12266.75, 12226.64, 12267.66, 12193.27, numFunction)); - bars.add(new MockBar(12219.79, 12288.17, 12303.16, 12219.79, numFunction)); - bars.add(new MockBar(12287.72, 12318.14, 12331.31, 12253.24, numFunction)); - bars.add(new MockBar(12389.74, 12212.79, 12389.82, 12176.31, numFunction)); - - data = new MockBarSeries(bars); } @Test public void testCreation() { - final KeltnerChannelFacade facade = new KeltnerChannelFacade(data, 14, 14, 2); + final var facade = new KeltnerChannelFacade(data, 14, 14, 2); assertEquals(data, facade.middle().getBarSeries()); } @Test public void testNumericFacadesSameAsDefaultIndicators() { - final KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); - final KeltnerChannelLowerIndicator kl = new KeltnerChannelLowerIndicator(km, 2, 14); - final KeltnerChannelUpperIndicator ku = new KeltnerChannelUpperIndicator(km, 2, 14); + final var km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); + final var kl = new KeltnerChannelLowerIndicator(km, 2, 14); + final var ku = new KeltnerChannelUpperIndicator(km, 2, 14); - final KeltnerChannelFacade facade = new KeltnerChannelFacade(data, 14, 14, 2); + final var facade = new KeltnerChannelFacade(data, 14, 14, 2); final NumericIndicator middleNumeric = facade.middle(); final NumericIndicator upperNumeric = facade.upper(); final NumericIndicator lowerNumeric = facade.lower(); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicatorTest.java index 27893c5fe..cd2df6e1f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelLowerIndicatorTest.java @@ -25,74 +25,66 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class KeltnerChannelLowerIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public KeltnerChannelLowerIndicatorTest(Function function) { - super(function); + public KeltnerChannelLowerIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - - List bars = new ArrayList(); - bars.add(new MockBar(11577.43, 11670.75, 11711.47, 11577.35, numFunction)); - bars.add(new MockBar(11670.90, 11691.18, 11698.22, 11635.74, numFunction)); - bars.add(new MockBar(11688.61, 11722.89, 11742.68, 11652.89, numFunction)); - bars.add(new MockBar(11716.93, 11697.31, 11736.74, 11667.46, numFunction)); - bars.add(new MockBar(11696.86, 11674.76, 11726.94, 11599.68, numFunction)); - bars.add(new MockBar(11672.34, 11637.45, 11677.33, 11573.87, numFunction)); - bars.add(new MockBar(11638.51, 11671.88, 11704.12, 11635.48, numFunction)); - bars.add(new MockBar(11673.62, 11755.44, 11782.23, 11673.62, numFunction)); - bars.add(new MockBar(11753.70, 11731.90, 11757.25, 11700.53, numFunction)); - bars.add(new MockBar(11732.13, 11787.38, 11794.15, 11698.83, numFunction)); - bars.add(new MockBar(11783.82, 11837.93, 11858.78, 11777.99, numFunction)); - bars.add(new MockBar(11834.21, 11825.29, 11861.24, 11798.46, numFunction)); - bars.add(new MockBar(11823.70, 11822.80, 11845.16, 11744.77, numFunction)); - bars.add(new MockBar(11822.95, 11871.84, 11905.48, 11822.80, numFunction)); - bars.add(new MockBar(11873.43, 11980.52, 11982.94, 11867.98, numFunction)); - bars.add(new MockBar(11980.52, 11977.19, 11985.97, 11898.74, numFunction)); - bars.add(new MockBar(11978.85, 11985.44, 12020.52, 11961.83, numFunction)); - bars.add(new MockBar(11985.36, 11989.83, 12019.53, 11971.93, numFunction)); - bars.add(new MockBar(11824.39, 11891.93, 11891.93, 11817.88, numFunction)); - bars.add(new MockBar(11892.50, 12040.16, 12050.75, 11892.50, numFunction)); - bars.add(new MockBar(12038.27, 12041.97, 12057.91, 12018.51, numFunction)); - bars.add(new MockBar(12040.68, 12062.26, 12080.54, 11981.05, numFunction)); - bars.add(new MockBar(12061.73, 12092.15, 12092.42, 12025.78, numFunction)); - bars.add(new MockBar(12092.38, 12161.63, 12188.76, 12092.30, numFunction)); - bars.add(new MockBar(12152.70, 12233.15, 12238.79, 12150.05, numFunction)); - bars.add(new MockBar(12229.29, 12239.89, 12254.23, 12188.19, numFunction)); - bars.add(new MockBar(12239.66, 12229.29, 12239.66, 12156.94, numFunction)); - bars.add(new MockBar(12227.78, 12273.26, 12285.94, 12180.48, numFunction)); - bars.add(new MockBar(12266.83, 12268.19, 12276.21, 12235.91, numFunction)); - bars.add(new MockBar(12266.75, 12226.64, 12267.66, 12193.27, numFunction)); - bars.add(new MockBar(12219.79, 12288.17, 12303.16, 12219.79, numFunction)); - bars.add(new MockBar(12287.72, 12318.14, 12331.31, 12253.24, numFunction)); - bars.add(new MockBar(12389.74, 12212.79, 12389.82, 12176.31, numFunction)); - - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(11577.43).closePrice(11670.75).highPrice(11711.47).lowPrice(11577.35).add(); + data.barBuilder().openPrice(11670.90).closePrice(11691.18).highPrice(11698.22).lowPrice(11635.74).add(); + data.barBuilder().openPrice(11688.61).closePrice(11722.89).highPrice(11742.68).lowPrice(11652.89).add(); + data.barBuilder().openPrice(11716.93).closePrice(11697.31).highPrice(11736.74).lowPrice(11667.46).add(); + data.barBuilder().openPrice(11696.86).closePrice(11674.76).highPrice(11726.94).lowPrice(11599.68).add(); + data.barBuilder().openPrice(11672.34).closePrice(11637.45).highPrice(11677.33).lowPrice(11573.87).add(); + data.barBuilder().openPrice(11638.51).closePrice(11671.88).highPrice(11704.12).lowPrice(11635.48).add(); + data.barBuilder().openPrice(11673.62).closePrice(11755.44).highPrice(11782.23).lowPrice(11673.62).add(); + data.barBuilder().openPrice(11753.70).closePrice(11731.90).highPrice(11757.25).lowPrice(11700.53).add(); + data.barBuilder().openPrice(11732.13).closePrice(11787.38).highPrice(11794.15).lowPrice(11698.83).add(); + data.barBuilder().openPrice(11783.82).closePrice(11837.93).highPrice(11858.78).lowPrice(11777.99).add(); + data.barBuilder().openPrice(11834.21).closePrice(11825.29).highPrice(11861.24).lowPrice(11798.46).add(); + data.barBuilder().openPrice(11823.70).closePrice(11822.80).highPrice(11845.16).lowPrice(11744.77).add(); + data.barBuilder().openPrice(11822.95).closePrice(11871.84).highPrice(11905.48).lowPrice(11822.80).add(); + data.barBuilder().openPrice(11873.43).closePrice(11980.52).highPrice(11982.94).lowPrice(11867.98).add(); + data.barBuilder().openPrice(11980.52).closePrice(11977.19).highPrice(11985.97).lowPrice(11898.74).add(); + data.barBuilder().openPrice(11978.85).closePrice(11985.44).highPrice(12020.52).lowPrice(11961.83).add(); + data.barBuilder().openPrice(11985.36).closePrice(11989.83).highPrice(12019.53).lowPrice(11971.93).add(); + data.barBuilder().openPrice(11824.39).closePrice(11891.93).highPrice(11891.93).lowPrice(11817.88).add(); + data.barBuilder().openPrice(11892.50).closePrice(12040.16).highPrice(12050.75).lowPrice(11892.50).add(); + data.barBuilder().openPrice(12038.27).closePrice(12041.97).highPrice(12057.91).lowPrice(12018.51).add(); + data.barBuilder().openPrice(12040.68).closePrice(12062.26).highPrice(12080.54).lowPrice(11981.05).add(); + data.barBuilder().openPrice(12061.73).closePrice(12092.15).highPrice(12092.42).lowPrice(12025.78).add(); + data.barBuilder().openPrice(12092.38).closePrice(12161.63).highPrice(12188.76).lowPrice(12092.30).add(); + data.barBuilder().openPrice(12152.70).closePrice(12233.15).highPrice(12238.79).lowPrice(12150.05).add(); + data.barBuilder().openPrice(12229.29).closePrice(12239.89).highPrice(12254.23).lowPrice(12188.19).add(); + data.barBuilder().openPrice(12239.66).closePrice(12229.29).highPrice(12239.66).lowPrice(12156.94).add(); + data.barBuilder().openPrice(12227.78).closePrice(12273.26).highPrice(12285.94).lowPrice(12180.48).add(); + data.barBuilder().openPrice(12266.83).closePrice(12268.19).highPrice(12276.21).lowPrice(12235.91).add(); + data.barBuilder().openPrice(12266.75).closePrice(12226.64).highPrice(12267.66).lowPrice(12193.27).add(); + data.barBuilder().openPrice(12219.79).closePrice(12288.17).highPrice(12303.16).lowPrice(12219.79).add(); + data.barBuilder().openPrice(12287.72).closePrice(12318.14).highPrice(12331.31).lowPrice(12253.24).add(); + data.barBuilder().openPrice(12389.74).closePrice(12212.79).highPrice(12389.82).lowPrice(12176.31).add(); } @Test public void keltnerChannelLowerIndicatorTest() { - KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); - KeltnerChannelLowerIndicator kl = new KeltnerChannelLowerIndicator(km, 2, 14); + var km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); + var kl = new KeltnerChannelLowerIndicator(km, 2, 14); assertNumEquals(11556.5468, kl.getValue(13)); assertNumEquals(11583.7971, kl.getValue(14)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelMiddleIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelMiddleIndicatorTest.java index bdd41ce1e..b197b136c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelMiddleIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelMiddleIndicatorTest.java @@ -25,68 +25,228 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class KeltnerChannelMiddleIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public KeltnerChannelMiddleIndicatorTest(Function function) { - super(function); + public KeltnerChannelMiddleIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(11577.43, 11670.75, 11711.47, 11577.35, numFunction)); - bars.add(new MockBar(11670.90, 11691.18, 11698.22, 11635.74, numFunction)); - bars.add(new MockBar(11688.61, 11722.89, 11742.68, 11652.89, numFunction)); - bars.add(new MockBar(11716.93, 11697.31, 11736.74, 11667.46, numFunction)); - bars.add(new MockBar(11696.86, 11674.76, 11726.94, 11599.68, numFunction)); - bars.add(new MockBar(11672.34, 11637.45, 11677.33, 11573.87, numFunction)); - bars.add(new MockBar(11638.51, 11671.88, 11704.12, 11635.48, numFunction)); - bars.add(new MockBar(11673.62, 11755.44, 11782.23, 11673.62, numFunction)); - bars.add(new MockBar(11753.70, 11731.90, 11757.25, 11700.53, numFunction)); - bars.add(new MockBar(11732.13, 11787.38, 11794.15, 11698.83, numFunction)); - bars.add(new MockBar(11783.82, 11837.93, 11858.78, 11777.99, numFunction)); - bars.add(new MockBar(11834.21, 11825.29, 11861.24, 11798.46, numFunction)); - bars.add(new MockBar(11823.70, 11822.80, 11845.16, 11744.77, numFunction)); - bars.add(new MockBar(11822.95, 11871.84, 11905.48, 11822.80, numFunction)); - bars.add(new MockBar(11873.43, 11980.52, 11982.94, 11867.98, numFunction)); - bars.add(new MockBar(11980.52, 11977.19, 11985.97, 11898.74, numFunction)); - bars.add(new MockBar(11978.85, 11985.44, 12020.52, 11961.83, numFunction)); - bars.add(new MockBar(11985.36, 11989.83, 12019.53, 11971.93, numFunction)); - bars.add(new MockBar(11824.39, 11891.93, 11891.93, 11817.88, numFunction)); - bars.add(new MockBar(11892.50, 12040.16, 12050.75, 11892.50, numFunction)); - bars.add(new MockBar(12038.27, 12041.97, 12057.91, 12018.51, numFunction)); - bars.add(new MockBar(12040.68, 12062.26, 12080.54, 11981.05, numFunction)); - bars.add(new MockBar(12061.73, 12092.15, 12092.42, 12025.78, numFunction)); - bars.add(new MockBar(12092.38, 12161.63, 12188.76, 12092.30, numFunction)); - bars.add(new MockBar(12152.70, 12233.15, 12238.79, 12150.05, numFunction)); - bars.add(new MockBar(12229.29, 12239.89, 12254.23, 12188.19, numFunction)); - bars.add(new MockBar(12239.66, 12229.29, 12239.66, 12156.94, numFunction)); - bars.add(new MockBar(12227.78, 12273.26, 12285.94, 12180.48, numFunction)); - bars.add(new MockBar(12266.83, 12268.19, 12276.21, 12235.91, numFunction)); - bars.add(new MockBar(12266.75, 12226.64, 12267.66, 12193.27, numFunction)); - bars.add(new MockBar(12219.79, 12288.17, 12303.16, 12219.79, numFunction)); - bars.add(new MockBar(12287.72, 12318.14, 12331.31, 12253.24, numFunction)); - bars.add(new MockBar(12389.74, 12212.79, 12389.82, 12176.31, numFunction)); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + data.addBar(data.barBuilder() + .openPrice(11577.43) + .closePrice(11670.75) + .highPrice(11711.47) + .lowPrice(11577.35) + .build()); + data.addBar(data.barBuilder() + .openPrice(11670.90) + .closePrice(11691.18) + .highPrice(11698.22) + .lowPrice(11635.74) + .build()); + data.addBar(data.barBuilder() + .openPrice(11688.61) + .closePrice(11722.89) + .highPrice(11742.68) + .lowPrice(11652.89) + .build()); + data.addBar(data.barBuilder() + .openPrice(11716.93) + .closePrice(11697.31) + .highPrice(11736.74) + .lowPrice(11667.46) + .build()); + data.addBar(data.barBuilder() + .openPrice(11696.86) + .closePrice(11674.76) + .highPrice(11726.94) + .lowPrice(11599.68) + .build()); + data.addBar(data.barBuilder() + .openPrice(11672.34) + .closePrice(11637.45) + .highPrice(11677.33) + .lowPrice(11573.87) + .build()); + data.addBar(data.barBuilder() + .openPrice(11638.51) + .closePrice(11671.88) + .highPrice(11704.12) + .lowPrice(11635.48) + .build()); + data.addBar(data.barBuilder() + .openPrice(11673.62) + .closePrice(11755.44) + .highPrice(11782.23) + .lowPrice(11673.62) + .build()); + data.addBar(data.barBuilder() + .openPrice(11753.70) + .closePrice(11731.90) + .highPrice(11757.25) + .lowPrice(11700.53) + .build()); + data.addBar(data.barBuilder() + .openPrice(11732.13) + .closePrice(11787.38) + .highPrice(11794.15) + .lowPrice(11698.83) + .build()); + data.addBar(data.barBuilder() + .openPrice(11783.82) + .closePrice(11837.93) + .highPrice(11858.78) + .lowPrice(11777.99) + .build()); + data.addBar(data.barBuilder() + .openPrice(11834.21) + .closePrice(11825.29) + .highPrice(11861.24) + .lowPrice(11798.46) + .build()); + data.addBar(data.barBuilder() + .openPrice(11823.70) + .closePrice(11822.80) + .highPrice(11845.16) + .lowPrice(11744.77) + .build()); + data.addBar(data.barBuilder() + .openPrice(11822.95) + .closePrice(11871.84) + .highPrice(11905.48) + .lowPrice(11822.80) + .build()); + data.addBar(data.barBuilder() + .openPrice(11873.43) + .closePrice(11980.52) + .highPrice(11982.94) + .lowPrice(11867.98) + .build()); + data.addBar(data.barBuilder() + .openPrice(11980.52) + .closePrice(11977.19) + .highPrice(11985.97) + .lowPrice(11898.74) + .build()); + data.addBar(data.barBuilder() + .openPrice(11978.85) + .closePrice(11985.44) + .highPrice(12020.52) + .lowPrice(11961.83) + .build()); + data.addBar(data.barBuilder() + .openPrice(11985.36) + .closePrice(11989.83) + .highPrice(12019.53) + .lowPrice(11971.93) + .build()); + data.addBar(data.barBuilder() + .openPrice(11824.39) + .closePrice(11891.93) + .highPrice(11891.93) + .lowPrice(11817.88) + .build()); + data.addBar(data.barBuilder() + .openPrice(11892.50) + .closePrice(12040.16) + .highPrice(12050.75) + .lowPrice(11892.50) + .build()); + data.addBar(data.barBuilder() + .openPrice(12038.27) + .closePrice(12041.97) + .highPrice(12057.91) + .lowPrice(12018.51) + .build()); + data.addBar(data.barBuilder() + .openPrice(12040.68) + .closePrice(12062.26) + .highPrice(12080.54) + .lowPrice(11981.05) + .build()); + data.addBar(data.barBuilder() + .openPrice(12061.73) + .closePrice(12092.15) + .highPrice(12092.42) + .lowPrice(12025.78) + .build()); + data.addBar(data.barBuilder() + .openPrice(12092.38) + .closePrice(12161.63) + .highPrice(12188.76) + .lowPrice(12092.30) + .build()); + data.addBar(data.barBuilder() + .openPrice(12152.70) + .closePrice(12233.15) + .highPrice(12238.79) + .lowPrice(12150.05) + .build()); + data.addBar(data.barBuilder() + .openPrice(12229.29) + .closePrice(12239.89) + .highPrice(12254.23) + .lowPrice(12188.19) + .build()); + data.addBar(data.barBuilder() + .openPrice(12239.66) + .closePrice(12229.29) + .highPrice(12239.66) + .lowPrice(12156.94) + .build()); + data.addBar(data.barBuilder() + .openPrice(12227.78) + .closePrice(12273.26) + .highPrice(12285.94) + .lowPrice(12180.48) + .build()); + data.addBar(data.barBuilder() + .openPrice(12266.83) + .closePrice(12268.19) + .highPrice(12276.21) + .lowPrice(12235.91) + .build()); + data.addBar(data.barBuilder() + .openPrice(12266.75) + .closePrice(12226.64) + .highPrice(12267.66) + .lowPrice(12193.27) + .build()); + data.addBar(data.barBuilder() + .openPrice(12219.79) + .closePrice(12288.17) + .highPrice(12303.16) + .lowPrice(12219.79) + .build()); + data.addBar(data.barBuilder() + .openPrice(12287.72) + .closePrice(12318.14) + .highPrice(12331.31) + .lowPrice(12253.24) + .build()); + data.addBar(data.barBuilder() + .openPrice(12389.74) + .closePrice(12212.79) + .highPrice(12389.82) + .lowPrice(12176.31) + .build()); - data = new MockBarSeries(bars); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicatorTest.java index 35d7a20c2..3a87fbaba 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/keltner/KeltnerChannelUpperIndicatorTest.java @@ -25,74 +25,67 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class KeltnerChannelUpperIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public KeltnerChannelUpperIndicatorTest(Function numFunction) { - super(numFunction); + public KeltnerChannelUpperIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(11577.43, 11670.75, 11711.47, 11577.35, numFunction)); - bars.add(new MockBar(11670.90, 11691.18, 11698.22, 11635.74, numFunction)); - bars.add(new MockBar(11688.61, 11722.89, 11742.68, 11652.89, numFunction)); - bars.add(new MockBar(11716.93, 11697.31, 11736.74, 11667.46, numFunction)); - bars.add(new MockBar(11696.86, 11674.76, 11726.94, 11599.68, numFunction)); - bars.add(new MockBar(11672.34, 11637.45, 11677.33, 11573.87, numFunction)); - bars.add(new MockBar(11638.51, 11671.88, 11704.12, 11635.48, numFunction)); - bars.add(new MockBar(11673.62, 11755.44, 11782.23, 11673.62, numFunction)); - bars.add(new MockBar(11753.70, 11731.90, 11757.25, 11700.53, numFunction)); - bars.add(new MockBar(11732.13, 11787.38, 11794.15, 11698.83, numFunction)); - bars.add(new MockBar(11783.82, 11837.93, 11858.78, 11777.99, numFunction)); - bars.add(new MockBar(11834.21, 11825.29, 11861.24, 11798.46, numFunction)); - bars.add(new MockBar(11823.70, 11822.80, 11845.16, 11744.77, numFunction)); - bars.add(new MockBar(11822.95, 11871.84, 11905.48, 11822.80, numFunction)); - bars.add(new MockBar(11873.43, 11980.52, 11982.94, 11867.98, numFunction)); - bars.add(new MockBar(11980.52, 11977.19, 11985.97, 11898.74, numFunction)); - bars.add(new MockBar(11978.85, 11985.44, 12020.52, 11961.83, numFunction)); - bars.add(new MockBar(11985.36, 11989.83, 12019.53, 11971.93, numFunction)); - bars.add(new MockBar(11824.39, 11891.93, 11891.93, 11817.88, numFunction)); - bars.add(new MockBar(11892.50, 12040.16, 12050.75, 11892.50, numFunction)); - bars.add(new MockBar(12038.27, 12041.97, 12057.91, 12018.51, numFunction)); - bars.add(new MockBar(12040.68, 12062.26, 12080.54, 11981.05, numFunction)); - bars.add(new MockBar(12061.73, 12092.15, 12092.42, 12025.78, numFunction)); - bars.add(new MockBar(12092.38, 12161.63, 12188.76, 12092.30, numFunction)); - bars.add(new MockBar(12152.70, 12233.15, 12238.79, 12150.05, numFunction)); - bars.add(new MockBar(12229.29, 12239.89, 12254.23, 12188.19, numFunction)); - bars.add(new MockBar(12239.66, 12229.29, 12239.66, 12156.94, numFunction)); - bars.add(new MockBar(12227.78, 12273.26, 12285.94, 12180.48, numFunction)); - bars.add(new MockBar(12266.83, 12268.19, 12276.21, 12235.91, numFunction)); - bars.add(new MockBar(12266.75, 12226.64, 12267.66, 12193.27, numFunction)); - bars.add(new MockBar(12219.79, 12288.17, 12303.16, 12219.79, numFunction)); - bars.add(new MockBar(12287.72, 12318.14, 12331.31, 12253.24, numFunction)); - bars.add(new MockBar(12389.74, 12212.79, 12389.82, 12176.31, numFunction)); - - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(11577.43).closePrice(11670.75).highPrice(11711.47).lowPrice(11577.35).add(); + data.barBuilder().openPrice(11670.90).closePrice(11691.18).highPrice(11698.22).lowPrice(11635.74).add(); + data.barBuilder().openPrice(11688.61).closePrice(11722.89).highPrice(11742.68).lowPrice(11652.89).add(); + data.barBuilder().openPrice(11716.93).closePrice(11697.31).highPrice(11736.74).lowPrice(11667.46).add(); + data.barBuilder().openPrice(11696.86).closePrice(11674.76).highPrice(11726.94).lowPrice(11599.68).add(); + data.barBuilder().openPrice(11672.34).closePrice(11637.45).highPrice(11677.33).lowPrice(11573.87).add(); + data.barBuilder().openPrice(11638.51).closePrice(11671.88).highPrice(11704.12).lowPrice(11635.48).add(); + data.barBuilder().openPrice(11673.62).closePrice(11755.44).highPrice(11782.23).lowPrice(11673.62).add(); + data.barBuilder().openPrice(11753.70).closePrice(11731.90).highPrice(11757.25).lowPrice(11700.53).add(); + data.barBuilder().openPrice(11732.13).closePrice(11787.38).highPrice(11794.15).lowPrice(11698.83).add(); + data.barBuilder().openPrice(11783.82).closePrice(11837.93).highPrice(11858.78).lowPrice(11777.99).add(); + data.barBuilder().openPrice(11834.21).closePrice(11825.29).highPrice(11861.24).lowPrice(11798.46).add(); + data.barBuilder().openPrice(11823.70).closePrice(11822.80).highPrice(11845.16).lowPrice(11744.77).add(); + data.barBuilder().openPrice(11822.95).closePrice(11871.84).highPrice(11905.48).lowPrice(11822.80).add(); + data.barBuilder().openPrice(11873.43).closePrice(11980.52).highPrice(11982.94).lowPrice(11867.98).add(); + data.barBuilder().openPrice(11980.52).closePrice(11977.19).highPrice(11985.97).lowPrice(11898.74).add(); + data.barBuilder().openPrice(11978.85).closePrice(11985.44).highPrice(12020.52).lowPrice(11961.83).add(); + data.barBuilder().openPrice(11985.36).closePrice(11989.83).highPrice(12019.53).lowPrice(11971.93).add(); + data.barBuilder().openPrice(11824.39).closePrice(11891.93).highPrice(11891.93).lowPrice(11817.88).add(); + data.barBuilder().openPrice(11892.50).closePrice(12040.16).highPrice(12050.75).lowPrice(11892.50).add(); + data.barBuilder().openPrice(12038.27).closePrice(12041.97).highPrice(12057.91).lowPrice(12018.51).add(); + data.barBuilder().openPrice(12040.68).closePrice(12062.26).highPrice(12080.54).lowPrice(11981.05).add(); + data.barBuilder().openPrice(12061.73).closePrice(12092.15).highPrice(12092.42).lowPrice(12025.78).add(); + data.barBuilder().openPrice(12092.38).closePrice(12161.63).highPrice(12188.76).lowPrice(12092.30).add(); + data.barBuilder().openPrice(12152.70).closePrice(12233.15).highPrice(12238.79).lowPrice(12150.05).add(); + data.barBuilder().openPrice(12229.29).closePrice(12239.89).highPrice(12254.23).lowPrice(12188.19).add(); + data.barBuilder().openPrice(12239.66).closePrice(12229.29).highPrice(12239.66).lowPrice(12156.94).add(); + data.barBuilder().openPrice(12227.78).closePrice(12273.26).highPrice(12285.94).lowPrice(12180.48).add(); + data.barBuilder().openPrice(12266.83).closePrice(12268.19).highPrice(12276.21).lowPrice(12235.91).add(); + data.barBuilder().openPrice(12266.75).closePrice(12226.64).highPrice(12267.66).lowPrice(12193.27).add(); + data.barBuilder().openPrice(12219.79).closePrice(12288.17).highPrice(12303.16).lowPrice(12219.79).add(); + data.barBuilder().openPrice(12287.72).closePrice(12318.14).highPrice(12331.31).lowPrice(12253.24).add(); + data.barBuilder().openPrice(12389.74).closePrice(12212.79).highPrice(12389.82).lowPrice(12176.31).add(); } @Test public void keltnerChannelUpperIndicatorTest() { - KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); - KeltnerChannelUpperIndicator ku = new KeltnerChannelUpperIndicator(km, 2, 14); + var km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); + var ku = new KeltnerChannelUpperIndicator(km, 2, 14); assertNumEquals(11971.9132, ku.getValue(13)); assertNumEquals(12002.3402, ku.getValue(14)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/numeric/NumericIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/numeric/NumericIndicatorTest.java index 0d428d77a..a881bf0b6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/numeric/NumericIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/numeric/NumericIndicatorTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertEquals; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; @@ -40,9 +38,10 @@ import org.ta4j.core.indicators.helpers.LowestValueIndicator; import org.ta4j.core.indicators.helpers.VolumeIndicator; import org.ta4j.core.indicators.statistics.StandardDeviationIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.CrossedDownIndicatorRule; import org.ta4j.core.rules.CrossedUpIndicatorRule; import org.ta4j.core.rules.OverIndicatorRule; @@ -50,13 +49,14 @@ public class NumericIndicatorTest extends AbstractIndicatorTest { - private final BarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1, - 0, -1, -2); + private final BarSeries series = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2) + .build(); private final ClosePriceIndicator cp1 = new ClosePriceIndicator(series); private final EMAIndicator ema = new EMAIndicator(cp1, 3); - public NumericIndicatorTest(Function numFunction) { - super(numFunction); + public NumericIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test @@ -221,11 +221,4 @@ public void barSeries() { final NumericIndicator numericIndicator = NumericIndicator.of(cp1); assertEquals(cp1.getBarSeries(), numericIndicator.getBarSeries()); } - - @Test - public void numOf() { - final NumericIndicator numericIndicator = NumericIndicator.of(cp1); - assertNumEquals(cp1.numOf(0), numericIndicator.numOf(0)); - } - -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicatorTest.java index 3e1a1d779..e97b9866d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/pivotpoints/PivotPointIndicatorTest.java @@ -45,7 +45,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class PivotPointIndicatorTest { @@ -605,8 +605,7 @@ public void initDataForDailyBarCount() { + "2017-10-06,21:55:00,171.95,172.25,171.95,172.24,287810,0\n" + "2017-10-06,22:00:00,172.24,172.37,172.16,172.23,1062537,0"; String[] dataLine = rawData5Minutes.split("\n"); - series5Minutes = new BaseBarSeries("FB_5_minutes"); - series5Minutes = new BaseBarSeries("FB_5_minutes"); + series5Minutes = new MockBarSeriesBuilder().withName("FB_5_minutes").build(); for (String aDataLine : dataLine) { String[] barData = aDataLine.split(","); ZonedDateTime date = ZonedDateTime.parse(barData[0] + " " + barData[1] + " PST", @@ -616,7 +615,14 @@ public void initDataForDailyBarCount() { double low = Double.parseDouble(barData[4]); double close = Double.parseDouble(barData[5]); double volume = Double.parseDouble(barData[6]); - series5Minutes.addBar(date, open, high, low, close, volume); + series5Minutes.barBuilder() + .endTime(date) + .openPrice(open) + .closePrice(close) + .highPrice(high) + .lowPrice(low) + .volume(volume) + .add(); } } @@ -800,7 +806,7 @@ public void initDataForWeeklyBarCount() { + "2017-10-06,21:00:00,171.68,171.71,171.36,171.6728,569716,0\n" + "2017-10-06,22:00:00,171.67,172.37,171.55,172.23,2317180,0"; String[] dataLine = rawData1Hours.split("\n"); - series1Hours = new BaseBarSeries("FB_1_hours"); + series1Hours = new MockBarSeriesBuilder().withName("FB_1_hours").build(); for (String aDataLine : dataLine) { String[] barData = aDataLine.split(","); ZonedDateTime date = ZonedDateTime.parse(barData[0] + " " + barData[1] + " PST", @@ -810,7 +816,14 @@ public void initDataForWeeklyBarCount() { double low = Double.parseDouble(barData[4]); double close = Double.parseDouble(barData[5]); double volume = Double.parseDouble(barData[6]); - series1Hours.addBar(date, open, high, low, close, volume); + series1Hours.barBuilder() + .endTime(date) + .openPrice(open) + .closePrice(close) + .highPrice(high) + .lowPrice(low) + .volume(volume) + .add(); } } @@ -977,7 +990,7 @@ public void initDataForMonthlyBarCount() { + "2017/01/04,118.6900,19594560.0000,117.5500,119.6600,117.2900\n" + "2017/01/03,116.8600,20635600.0000,116.0300,117.8400,115.5100"; String[] dataLine = rawData1Days.split("\n"); - series1Days = new BaseBarSeries("FB_daily"); + series1Days = new MockBarSeriesBuilder().withName("FB_daily").build(); for (int i = dataLine.length - 1; i >= 0; i--) { String[] barData = dataLine[i].split(","); ZonedDateTime date = LocalDate.parse(barData[0], DateTimeFormatter.ofPattern("yyyy/MM/dd")) @@ -987,7 +1000,14 @@ public void initDataForMonthlyBarCount() { double open = Double.parseDouble(barData[3]); double high = Double.parseDouble(barData[4]); double low = Double.parseDouble(barData[5]); - series1Days.addBar(date, open, high, low, close, volume); + series1Days.barBuilder() + .endTime(date) + .openPrice(open) + .highPrice(high) + .lowPrice(low) + .closePrice(close) + .volume(volume) + .add(); } } @@ -1277,7 +1297,7 @@ public void initDataForYearlyBarCount() { + "2017-09-25,169.240005,171.660004,161.559998,170.869995,170.869995,111376500\n" + "2017-10-02,171.389999,172.369995,168.289993,172.229996,172.229996,60993900"; String[] dataLine = rawData1Week.split("\n"); - series1Weeks = new BaseBarSeries("FB_daily"); + series1Weeks = new MockBarSeriesBuilder().withName("FB_daily").build(); for (String aDataLine : dataLine) { String[] barData = aDataLine.split(","); ZonedDateTime date = LocalDate.parse(barData[0], DateTimeFormatter.ofPattern("yyyy-MM-dd")) @@ -1287,7 +1307,14 @@ public void initDataForYearlyBarCount() { double low = Double.parseDouble(barData[3]); double close = Double.parseDouble(barData[4]); double volume = Double.parseDouble(barData[6]); - series1Weeks.addBar(date, open, high, low, close, volume); + series1Weeks.barBuilder() + .endTime(date) + .openPrice(open) + .highPrice(high) + .lowPrice(low) + .closePrice(close) + .volume(volume) + .add(); } } @@ -1390,26 +1417,48 @@ public void PivotPointTestWeeklyBarCount() { assertEquals(fibS2.getValue(series1Hours.getBeginIndex()), NaN); assertEquals(fibS3.getValue(6), NaN); - assertEquals(fibR3.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .plus(series1Hours.one().multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); + assertEquals(fibR3.getValue(series1Hours.getEndIndex()), + pp.getValue(series1Hours.getEndIndex()) + .plus(series1Hours.numFactory() + .one() + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); assertEquals(fibR2.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .plus(series1Hours.numOf(0.618) - .multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); + .plus(series1Hours.numFactory() + .numOf(0.618) + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); assertEquals(fibR1.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .plus(series1Hours.numOf(0.382) - .multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); + .plus(series1Hours.numFactory() + .numOf(0.382) + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); assertEquals(fibS1.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .minus(series1Hours.numOf(0.382) - .multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); + .minus(series1Hours.numFactory() + .numOf(0.382) + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); assertEquals(fibS2.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .minus(series1Hours.numOf(0.618) - .multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); - assertEquals(fibS3.getValue(series1Hours.getEndIndex()), pp.getValue(series1Hours.getEndIndex()) - .minus(series1Hours.one().multipliedBy(series1Hours.numOf(171.66).minus(series1Hours.numOf(161.56))))); + .minus(series1Hours.numFactory() + .numOf(0.618) + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); + assertEquals(fibS3.getValue(series1Hours.getEndIndex()), + pp.getValue(series1Hours.getEndIndex()) + .minus(series1Hours.numFactory() + .one() + .multipliedBy(series1Hours.numFactory() + .numOf(171.66) + .minus(series1Hours.numFactory().numOf(161.56))))); DeMarkPivotPointIndicator deMarkpp = new DeMarkPivotPointIndicator(series1Hours, WEEK); DeMarkReversalIndicator deMarkR1 = new DeMarkReversalIndicator(deMarkpp, diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CorrelationCoefficientIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CorrelationCoefficientIndicatorTest.java index 7c037efc7..309c779f7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CorrelationCoefficientIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CorrelationCoefficientIndicatorTest.java @@ -27,52 +27,51 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.VolumeIndicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CorrelationCoefficientIndicatorTest extends AbstractIndicatorTest, Num> { private Indicator close, volume; - public CorrelationCoefficientIndicatorTest(Function numFunction) { - super(numFunction); + public CorrelationCoefficientIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + BarSeries data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); int i = 20; // close, volume - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 6, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 7, 105, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 10, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 13, 120, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 15, 180, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 200, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 85, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 70, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 5, 90, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 110, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i), 10, 95, numFunction)); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(6).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(7).volume(105).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(10).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(13).volume(120).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(15).volume(180).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(200).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(85).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(70).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(5).volume(90).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(110).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i)).closePrice(10).volume(95).add(); close = new ClosePriceIndicator(data); volume = new VolumeIndicator(data, 2); @@ -80,7 +79,7 @@ public void setUp() { @Test public void usingBarCount5UsingClosePriceAndVolume() { - CorrelationCoefficientIndicator coef = new CorrelationCoefficientIndicator(close, volume, 5); + var coef = new CorrelationCoefficientIndicator(close, volume, 5); assertTrue(coef.getValue(0).isNaN()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CovarianceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CovarianceIndicatorTest.java index 1e872a1b9..019254b79 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CovarianceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/CovarianceIndicatorTest.java @@ -26,59 +26,57 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.VolumeIndicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class CovarianceIndicatorTest extends AbstractIndicatorTest, Num> { private Indicator close, volume; - public CovarianceIndicatorTest(Function numFunction) { - super(numFunction); + public CovarianceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + BarSeries data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); int i = 20; - // close, volume - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 6, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 7, 105, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 10, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 13, 120, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 15, 180, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 200, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 85, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 70, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 5, 90, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 110, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i), 10, 95, numFunction)); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(6).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(7).volume(105).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(10).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(13).volume(120).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(15).volume(180).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(200).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(85).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(70).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(5).volume(90).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(110).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i)).closePrice(10).volume(95).add(); close = new ClosePriceIndicator(data); volume = new VolumeIndicator(data, 2); } @Test public void usingBarCount5UsingClosePriceAndVolume() { - CovarianceIndicator covar = new CovarianceIndicator(close, volume, 5); + var covar = new CovarianceIndicator(close, volume, 5); assertNumEquals(0, covar.getValue(0)); assertNumEquals(26.25, covar.getValue(1)); @@ -104,13 +102,13 @@ public void usingBarCount5UsingClosePriceAndVolume() { @Test public void firstValueShouldBeZero() { - CovarianceIndicator covar = new CovarianceIndicator(close, volume, 5); + var covar = new CovarianceIndicator(close, volume, 5); assertNumEquals(0, covar.getValue(0)); } @Test public void shouldBeZeroWhenBarCountIs1() { - CovarianceIndicator covar = new CovarianceIndicator(close, volume, 1); + var covar = new CovarianceIndicator(close, volume, 1); assertNumEquals(0, covar.getValue(3)); assertNumEquals(0, covar.getValue(8)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicatorTest.java index 9f3ba0e0c..3008e6d14 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/MeanDeviationIndicatorTest.java @@ -25,33 +25,32 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MeanDeviationIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public MeanDeviationIndicatorTest(Function numFunction) { - super(numFunction); + public MeanDeviationIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 7, 6, 3, 4, 5, 11, 3, 0, 9); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 7, 6, 3, 4, 5, 11, 3, 0, 9).build(); } @Test public void meanDeviationUsingBarCount5UsingClosePrice() { - MeanDeviationIndicator meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 5); + var meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 5); assertNumEquals(2.44444444444444, meanDeviation.getValue(2)); assertNumEquals(2.5, meanDeviation.getValue(3)); @@ -62,13 +61,13 @@ public void meanDeviationUsingBarCount5UsingClosePrice() { @Test public void firstValueShouldBeZero() { - MeanDeviationIndicator meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 5); + var meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 5); assertNumEquals(0, meanDeviation.getValue(0)); } @Test public void meanDeviationShouldBeZeroWhenBarCountIs1() { - MeanDeviationIndicator meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 1); + var meanDeviation = new MeanDeviationIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(0, meanDeviation.getValue(2)); assertNumEquals(0, meanDeviation.getValue(7)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicatorTest.java index 801ff2870..4addace03 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PearsonCorrelationIndicatorTest.java @@ -26,52 +26,51 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import java.time.ZonedDateTime; -import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.indicators.helpers.VolumeIndicator; -import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PearsonCorrelationIndicatorTest extends AbstractIndicatorTest, Num> { private Indicator close, volume; - public PearsonCorrelationIndicatorTest(Function function) { - super(function); + public PearsonCorrelationIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries data = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(); + BarSeries data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); int i = 20; // close, volume - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 6, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 7, 105, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 10, 130, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 13, 120, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 15, 180, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 12, 160, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 200, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 150, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 4, 85, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 3, 70, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 5, 90, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 8, 100, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 9, 95, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i--), 11, 110, numFunction)); - data.addBar(new MockBar(ZonedDateTime.now().minusSeconds(i), 10, 95, numFunction)); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(6).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(7).volume(105).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(10).volume(130).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(13).volume(120).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(15).volume(180).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(12).volume(160).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(200).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(150).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(4).volume(85).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(3).volume(70).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(5).volume(90).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(8).volume(100).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(9).volume(95).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i--)).closePrice(11).volume(110).add(); + data.barBuilder().endTime(ZonedDateTime.now().minusSeconds(i)).closePrice(10).volume(95).add(); close = new ClosePriceIndicator(data); volume = new VolumeIndicator(data, 2); @@ -79,7 +78,7 @@ public void setUp() { @Test public void test() { - PearsonCorrelationIndicator coef = new PearsonCorrelationIndicator(close, volume, 5); + var coef = new PearsonCorrelationIndicator(close, volume, 5); assertNumEquals(0.94947469058476818628408908843839, coef.getValue(1)); assertNumEquals(0.9640797490298872, coef.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicatorTest.java index d82800d75..5005bbeef 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/PeriodicalGrowthRateIndicatorTest.java @@ -27,11 +27,8 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import static org.ta4j.core.num.NaN.NaN; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.BaseStrategy; import org.ta4j.core.Indicator; import org.ta4j.core.Rule; @@ -39,8 +36,9 @@ import org.ta4j.core.backtest.BarSeriesManager; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; import org.ta4j.core.rules.CrossedDownIndicatorRule; import org.ta4j.core.rules.CrossedUpIndicatorRule; @@ -50,29 +48,31 @@ public class PeriodicalGrowthRateIndicatorTest extends AbstractIndicatorTest numFunction) { - super(numFunction); + public PeriodicalGrowthRateIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - BarSeries mockSeries = new MockBarSeries(numFunction, 29.49, 28.30, 27.74, 27.65, 27.60, 28.70, 28.60, 28.19, - 27.40, 27.20, 27.28, 27.00, 27.59, 26.20, 25.75, 24.75, 23.33, 24.45, 24.25, 25.02, 23.60, 24.20, 24.28, - 25.70, 25.46, 25.10, 25.00, 25.00, 25.85); + var mockSeries = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(29.49, 28.30, 27.74, 27.65, 27.60, 28.70, 28.60, 28.19, 27.40, 27.20, 27.28, 27.00, 27.59, + 26.20, 25.75, 24.75, 23.33, 24.45, 24.25, 25.02, 23.60, 24.20, 24.28, 25.70, 25.46, 25.10, + 25.00, 25.00, 25.85) + .build(); seriesManager = new BarSeriesManager(mockSeries); closePrice = new ClosePriceIndicator(mockSeries); } @Test public void testGetTotalReturn() { - PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); + var gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); Num result = gri.getTotalReturn(); assertNumEquals(0.9564, result); } @Test public void testCalculation() { - PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); + var gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); assertEquals(gri.getValue(0), NaN); assertEquals(gri.getValue(4), NaN); @@ -88,7 +88,7 @@ public void testCalculation() { @Test public void testStrategies() { - PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); + var gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); // Rules Rule buyingRule = new CrossedUpIndicatorRule(gri, 0); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SigmaIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SigmaIndicatorTest.java index b1c5311c8..56403234e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SigmaIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SigmaIndicatorTest.java @@ -25,34 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class SigmaIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public SigmaIndicatorTest(Function numFunction) { + public SigmaIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 5, 6); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 4, 5, 6).build(); } @Test public void test() { - SigmaIndicator zScore = new SigmaIndicator(new ClosePriceIndicator(data), 5); + var zScore = new SigmaIndicator(new ClosePriceIndicator(data), 5); assertNumEquals(1.0, zScore.getValue(1)); assertNumEquals(1.224744871391589, zScore.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicatorTest.java index 8689fba94..f17a518a6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/SimpleLinearRegressionIndicatorTest.java @@ -26,35 +26,35 @@ import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.apache.commons.math3.stat.regression.SimpleRegression; import org.junit.Before; import org.junit.Test; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class SimpleLinearRegressionIndicatorTest extends AbstractIndicatorTest, Num> { private Indicator closePrice; - public SimpleLinearRegressionIndicatorTest(Function numFunction) { - super(numFunction); + public SimpleLinearRegressionIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { double[] data = { 10, 20, 30, 40, 30, 40, 30, 20, 30, 50, 60, 70, 80 }; - closePrice = new ClosePriceIndicator(new MockBarSeries(numFunction, data)); + closePrice = new ClosePriceIndicator( + new MockBarSeriesBuilder().withNumFactory(numFactory).withData(data).build()); } @Test public void notComputedLinearRegression() { - SimpleLinearRegressionIndicator linearReg = new SimpleLinearRegressionIndicator(closePrice, 0); + var linearReg = new SimpleLinearRegressionIndicator(closePrice, 0); assertTrue(linearReg.getValue(0).isNaN()); assertTrue(linearReg.getValue(1).isNaN()); assertTrue(linearReg.getValue(2).isNaN()); @@ -67,7 +67,7 @@ public void notComputedLinearRegression() { @Test public void calculateLinearRegressionWithLessThan2ObservationsReturnsNaN() { - SimpleLinearRegressionIndicator reg = new SimpleLinearRegressionIndicator(closePrice, 0); + var reg = new SimpleLinearRegressionIndicator(closePrice, 0); assertTrue(reg.getValue(0).isNaN()); assertTrue(reg.getValue(3).isNaN()); assertTrue(reg.getValue(6).isNaN()); @@ -82,7 +82,7 @@ public void calculateLinearRegressionWithLessThan2ObservationsReturnsNaN() { @Test public void calculateLinearRegressionOn4Observations() { - SimpleLinearRegressionIndicator reg = new SimpleLinearRegressionIndicator(closePrice, 4); + var reg = new SimpleLinearRegressionIndicator(closePrice, 4); assertNumEquals(20, reg.getValue(1)); assertNumEquals(30, reg.getValue(2)); @@ -100,8 +100,9 @@ public void calculateLinearRegressionOn4Observations() { @Test public void calculateLinearRegression() { double[] values = { 1, 2, 1.3, 3.75, 2.25 }; - ClosePriceIndicator indicator = new ClosePriceIndicator(new MockBarSeries(numFunction, values)); - SimpleLinearRegressionIndicator reg = new SimpleLinearRegressionIndicator(indicator, 5); + var indicator = new ClosePriceIndicator( + new MockBarSeriesBuilder().withNumFactory(numFactory).withData(values).build()); + var reg = new SimpleLinearRegressionIndicator(indicator, 5); SimpleRegression origReg = buildSimpleRegression(values); assertNumEquals(origReg.predict(4), reg.getValue(4)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardDeviationIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardDeviationIndicatorTest.java index 2611f037f..5727b0ac2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardDeviationIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardDeviationIndicatorTest.java @@ -25,32 +25,31 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StandardDeviationIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public StandardDeviationIndicatorTest(Function numFunction) { + public StandardDeviationIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 0, 9); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 0, 9).build(); } @Test public void standardDeviationUsingBarCount4UsingClosePrice() { - StandardDeviationIndicator sdv = new StandardDeviationIndicator(new ClosePriceIndicator(data), 4); + var sdv = new StandardDeviationIndicator(new ClosePriceIndicator(data), 4); assertNumEquals(0, sdv.getValue(0)); assertNumEquals(Math.sqrt(0.25), sdv.getValue(1)); @@ -67,7 +66,7 @@ public void standardDeviationUsingBarCount4UsingClosePrice() { @Test public void standardDeviationShouldBeZeroWhenBarCountIs1() { - StandardDeviationIndicator sdv = new StandardDeviationIndicator(new ClosePriceIndicator(data), 1); + var sdv = new StandardDeviationIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(0, sdv.getValue(3)); assertNumEquals(0, sdv.getValue(8)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardErrorIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardErrorIndicatorTest.java index 86ebb6d89..8201c7ef3 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardErrorIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/StandardErrorIndicatorTest.java @@ -25,32 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StandardErrorIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public StandardErrorIndicatorTest(Function numFunction) { - super(numFunction); + public StandardErrorIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 10, 20, 30, 40, 50, 40, 40, 50, 40, 30, 20, 10); + data = new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(10, 20, 30, 40, 50, 40, 40, 50, 40, 30, 20, 10) + .build(); } @Test public void usingBarCount5UsingClosePrice() { - StandardErrorIndicator se = new StandardErrorIndicator(new ClosePriceIndicator(data), 5); + var se = new StandardErrorIndicator(new ClosePriceIndicator(data), 5); assertNumEquals(0, se.getValue(0)); assertNumEquals(3.5355, se.getValue(1)); @@ -68,7 +69,7 @@ public void usingBarCount5UsingClosePrice() { @Test public void shouldBeZeroWhenBarCountIs1() { - StandardErrorIndicator se = new StandardErrorIndicator(new ClosePriceIndicator(data), 1); + var se = new StandardErrorIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(0, se.getValue(1)); assertNumEquals(0, se.getValue(3)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/VarianceIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/VarianceIndicatorTest.java index d4f5a3e85..e01079ac0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/VarianceIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/statistics/VarianceIndicatorTest.java @@ -25,32 +25,31 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class VarianceIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries data; - public VarianceIndicatorTest(Function numFunction) { - super(numFunction); + public VarianceIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - data = new MockBarSeries(numFunction, 1, 2, 3, 4, 3, 4, 5, 4, 3, 0, 9); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).withData(1, 2, 3, 4, 3, 4, 5, 4, 3, 0, 9).build(); } @Test public void varianceUsingBarCount4UsingClosePrice() { - VarianceIndicator var = new VarianceIndicator(new ClosePriceIndicator(data), 4); + var var = new VarianceIndicator(new ClosePriceIndicator(data), 4); assertNumEquals(0, var.getValue(0)); assertNumEquals(0.25, var.getValue(1)); @@ -67,20 +66,20 @@ public void varianceUsingBarCount4UsingClosePrice() { @Test public void firstValueShouldBeZero() { - VarianceIndicator var = new VarianceIndicator(new ClosePriceIndicator(data), 4); + var var = new VarianceIndicator(new ClosePriceIndicator(data), 4); assertNumEquals(0, var.getValue(0)); } @Test public void varianceShouldBeZeroWhenBarCountIs1() { - VarianceIndicator var = new VarianceIndicator(new ClosePriceIndicator(data), 1); + var var = new VarianceIndicator(new ClosePriceIndicator(data), 1); assertNumEquals(0, var.getValue(3)); assertNumEquals(0, var.getValue(8)); } @Test public void varianceUsingBarCount2UsingClosePrice() { - VarianceIndicator var = new VarianceIndicator(new ClosePriceIndicator(data), 2); + var var = new VarianceIndicator(new ClosePriceIndicator(data), 2); assertNumEquals(0, var.getValue(0)); assertNumEquals(0.25, var.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java index ab639853c..f07060be8 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java @@ -25,76 +25,64 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.Indicator; -import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; - -public class SuperTrendIndicatorTest extends AbstractIndicatorTest, Num> { +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DoubleNumFactory; +import org.ta4j.core.num.NumFactory; - BarSeries data; +public class SuperTrendIndicatorTest { - public SuperTrendIndicatorTest(Function numFunction) { - super(DoubleNum::valueOf); - } + private BarSeries data; + private NumFactory numFactory = new DoubleNumFactory(); @Before public void setUp() { - List bars = new ArrayList<>(); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); - bars.add(new MockBar(23.17, 21.48, 23.39, 21.35, numFunction)); - bars.add(new MockBar(21.25, 19.94, 21.29, 20.07, numFunction)); - bars.add(new MockBar(20.08, 21.97, 24.30, 20.01, numFunction)); - bars.add(new MockBar(22.17, 20.87, 22.64, 20.78, numFunction)); - bars.add(new MockBar(21.67, 21.65, 22.80, 21.59, numFunction)); - bars.add(new MockBar(21.47, 22.14, 22.26, 20.96, numFunction)); - bars.add(new MockBar(22.25, 21.44, 22.31, 21.36, numFunction)); - bars.add(new MockBar(21.83, 21.67, 22.40, 21.59, numFunction)); - bars.add(new MockBar(23.09, 22.90, 23.76, 22.73, numFunction)); - bars.add(new MockBar(22.93, 22.01, 23.27, 21.94, numFunction)); - bars.add(new MockBar(19.89, 19.20, 20.47, 18.91, numFunction)); - bars.add(new MockBar(21.56, 18.83, 21.80, 18.83, numFunction)); - bars.add(new MockBar(19.00, 18.35, 19.41, 18.01, numFunction)); - bars.add(new MockBar(19.89, 6.36, 20.22, 6.21, numFunction)); - bars.add(new MockBar(19.28, 10.34, 20.58, 10.11, numFunction)); + data.barBuilder().openPrice(23.17).closePrice(21.48).highPrice(23.39).lowPrice(21.35).add(); + data.barBuilder().openPrice(21.25).closePrice(19.94).highPrice(21.29).lowPrice(20.07).add(); + data.barBuilder().openPrice(20.08).closePrice(21.97).highPrice(24.30).lowPrice(20.01).add(); + data.barBuilder().openPrice(22.17).closePrice(20.87).highPrice(22.64).lowPrice(20.78).add(); + data.barBuilder().openPrice(21.67).closePrice(21.65).highPrice(22.80).lowPrice(21.59).add(); + data.barBuilder().openPrice(21.47).closePrice(22.14).highPrice(22.26).lowPrice(20.96).add(); + data.barBuilder().openPrice(22.25).closePrice(21.44).highPrice(22.31).lowPrice(21.36).add(); + data.barBuilder().openPrice(21.83).closePrice(21.67).highPrice(22.40).lowPrice(21.59).add(); + data.barBuilder().openPrice(23.09).closePrice(22.90).highPrice(23.76).lowPrice(22.73).add(); + data.barBuilder().openPrice(22.93).closePrice(22.01).highPrice(23.27).lowPrice(21.94).add(); + data.barBuilder().openPrice(19.89).closePrice(19.20).highPrice(20.47).lowPrice(18.91).add(); + data.barBuilder().openPrice(21.56).closePrice(18.83).highPrice(21.80).lowPrice(18.83).add(); + data.barBuilder().openPrice(19.00).closePrice(18.35).highPrice(19.41).lowPrice(18.01).add(); + data.barBuilder().openPrice(19.89).closePrice(6.36).highPrice(20.22).lowPrice(6.21).add(); + data.barBuilder().openPrice(19.28).closePrice(10.34).highPrice(20.58).lowPrice(10.11).add(); // this mock bar exemplify an edge case, the close price is the same as the // previous Super Trend value - bars.add(new MockBar(19.28, 22.78938583966133, 23.58, 10.11, numFunction)); - bars.add(new MockBar(19.28, 10.34, 20.58, 10.11, numFunction)); - bars.add(new MockBar(10.34, 9.83, 12.80, 8.83, numFunction)); - bars.add(new MockBar(11.83, 7.35, 11.41, 5.01, numFunction)); + data.barBuilder().openPrice(19.28).closePrice(22.78938583966133).highPrice(23.58).lowPrice(10.11).add(); + data.barBuilder().openPrice(19.28).closePrice(10.34).highPrice(20.58).lowPrice(10.11).add(); + data.barBuilder().openPrice(10.34).closePrice(9.83).highPrice(12.80).lowPrice(8.83).add(); + data.barBuilder().openPrice(11.83).closePrice(7.35).highPrice(11.41).lowPrice(5.01).add(); - data = new MockBarSeries(bars); } @Test public void testSuperTrendIndicator() { - SuperTrendIndicator superTrendIndicator = new SuperTrendIndicator(data); + var superTrendIndicator = new SuperTrendIndicator(data); - assertNumEquals(this.numOf(15.730621000000003), superTrendIndicator.getValue(4)); - assertNumEquals(this.numOf(17.602360938100002), superTrendIndicator.getValue(9)); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(14)); + assertNumEquals(numFactory.numOf(15.730621000000003), superTrendIndicator.getValue(4)); + assertNumEquals(numFactory.numOf(17.602360938100002), superTrendIndicator.getValue(9)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(14)); } @Test public void regressionTestOnZeroSuperTrendValueWhenClosePriceIsEqualToPreviousSuperTrendValue() { // bug: https://github.com/ta4j/ta4j/issues/1120 - SuperTrendIndicator superTrendIndicator = new SuperTrendIndicator(data); + var superTrendIndicator = new SuperTrendIndicator(data); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(14)); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(15)); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(16)); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(17)); - assertNumEquals(this.numOf(22.78938583966133), superTrendIndicator.getValue(18)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(14)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(15)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(16)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(17)); + assertNumEquals(numFactory.numOf(22.78938583966133), superTrendIndicator.getValue(18)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java index 1cc896fd5..d7f693bdf 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java @@ -25,58 +25,44 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.Indicator; -import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; - -public class SuperTrendLowerBandIndicatorTest extends AbstractIndicatorTest, Num> { +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DoubleNumFactory; +import org.ta4j.core.num.NumFactory; - BarSeries data; +public class SuperTrendLowerBandIndicatorTest { - public SuperTrendLowerBandIndicatorTest(Function numFunction) { - super(DoubleNum::valueOf); - } + private BarSeries data; + private NumFactory numFactory = new DoubleNumFactory(); @Before public void setUp() { - List bars = new ArrayList<>(); - - bars.add(new MockBar(23.17, 21.48, 23.39, 21.35, numFunction)); - bars.add(new MockBar(21.25, 19.94, 21.29, 20.07, numFunction)); - bars.add(new MockBar(20.08, 21.97, 24.30, 20.01, numFunction)); - bars.add(new MockBar(22.17, 20.87, 22.64, 20.78, numFunction)); - bars.add(new MockBar(21.67, 21.65, 22.80, 21.59, numFunction)); - bars.add(new MockBar(21.47, 22.14, 22.26, 20.96, numFunction)); - bars.add(new MockBar(22.25, 21.44, 22.31, 21.36, numFunction)); - bars.add(new MockBar(21.83, 21.67, 22.40, 21.59, numFunction)); - bars.add(new MockBar(23.09, 22.90, 23.76, 22.73, numFunction)); - bars.add(new MockBar(22.93, 22.01, 23.27, 21.94, numFunction)); - bars.add(new MockBar(19.89, 19.20, 20.47, 18.91, numFunction)); - bars.add(new MockBar(21.56, 18.83, 21.80, 18.83, numFunction)); - bars.add(new MockBar(19.00, 18.35, 19.41, 18.01, numFunction)); - bars.add(new MockBar(19.89, 6.36, 20.22, 6.21, numFunction)); - bars.add(new MockBar(19.28, 10.34, 20.58, 10.11, numFunction)); - - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(23.17).closePrice(21.48).highPrice(23.39).lowPrice(21.35).add(); + data.barBuilder().openPrice(21.25).closePrice(19.94).highPrice(21.29).lowPrice(20.07).add(); + data.barBuilder().openPrice(20.08).closePrice(21.97).highPrice(24.30).lowPrice(20.01).add(); + data.barBuilder().openPrice(22.17).closePrice(20.87).highPrice(22.64).lowPrice(20.78).add(); + data.barBuilder().openPrice(21.67).closePrice(21.65).highPrice(22.80).lowPrice(21.59).add(); + data.barBuilder().openPrice(21.47).closePrice(22.14).highPrice(22.26).lowPrice(20.96).add(); + data.barBuilder().openPrice(22.25).closePrice(21.44).highPrice(22.31).lowPrice(21.36).add(); + data.barBuilder().openPrice(21.83).closePrice(21.67).highPrice(22.40).lowPrice(21.59).add(); + data.barBuilder().openPrice(23.09).closePrice(22.90).highPrice(23.76).lowPrice(22.73).add(); + data.barBuilder().openPrice(22.93).closePrice(22.01).highPrice(23.27).lowPrice(21.94).add(); + data.barBuilder().openPrice(19.89).closePrice(19.20).highPrice(20.47).lowPrice(18.91).add(); + data.barBuilder().openPrice(21.56).closePrice(18.83).highPrice(21.80).lowPrice(18.83).add(); + data.barBuilder().openPrice(19.00).closePrice(18.35).highPrice(19.41).lowPrice(18.01).add(); + data.barBuilder().openPrice(19.89).closePrice(6.36).highPrice(20.22).lowPrice(6.21).add(); + data.barBuilder().openPrice(19.28).closePrice(10.34).highPrice(20.58).lowPrice(10.11).add(); } @Test public void testSuperTrendLowerBandIndicator() { - SuperTrendLowerBandIndicator superTrendLowerBandIndicator = new SuperTrendLowerBandIndicator(data); + var superTrendLowerBandIndicator = new SuperTrendLowerBandIndicator(data); - assertNumEquals(this.numOf(15.730621000000003), superTrendLowerBandIndicator.getValue(4)); - assertNumEquals(this.numOf(17.602360938100002), superTrendLowerBandIndicator.getValue(9)); - assertNumEquals(this.numOf(2.4620527443048026), superTrendLowerBandIndicator.getValue(14)); + assertNumEquals(numFactory.numOf(15.730621000000003), superTrendLowerBandIndicator.getValue(4)); + assertNumEquals(numFactory.numOf(17.602360938100002), superTrendLowerBandIndicator.getValue(9)); + assertNumEquals(numFactory.numOf(2.4620527443048026), superTrendLowerBandIndicator.getValue(14)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java index 18a50455c..9a983d8b7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java @@ -25,59 +25,48 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.Indicator; -import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DoubleNum; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DoubleNumFactory; +import org.ta4j.core.num.NumFactory; -public class SuperTrendUpperBandIndicatorTest extends AbstractIndicatorTest, Num> { +public class SuperTrendUpperBandIndicatorTest { - BarSeries data; + private BarSeries data; - public SuperTrendUpperBandIndicatorTest(Function numFunction) { - super(DoubleNum::valueOf); - } + private NumFactory numFactory = new DoubleNumFactory(); @Before public void setUp() { - List bars = new ArrayList<>(); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); - bars.add(new MockBar(23.17, 21.48, 23.39, 21.35, numFunction)); - bars.add(new MockBar(21.25, 19.94, 21.29, 20.07, numFunction)); - bars.add(new MockBar(20.08, 21.97, 24.30, 20.01, numFunction)); - bars.add(new MockBar(22.17, 20.87, 22.64, 20.78, numFunction)); - bars.add(new MockBar(21.67, 21.65, 22.80, 21.59, numFunction)); - bars.add(new MockBar(21.47, 22.14, 22.26, 20.96, numFunction)); - bars.add(new MockBar(22.25, 21.44, 22.31, 21.36, numFunction)); - bars.add(new MockBar(21.83, 21.67, 22.40, 21.59, numFunction)); - bars.add(new MockBar(23.09, 22.90, 23.76, 22.73, numFunction)); - bars.add(new MockBar(22.93, 22.01, 23.27, 21.94, numFunction)); - bars.add(new MockBar(19.89, 19.20, 20.47, 18.91, numFunction)); - bars.add(new MockBar(21.56, 18.83, 21.80, 18.83, numFunction)); - bars.add(new MockBar(19.00, 18.35, 19.41, 18.01, numFunction)); - bars.add(new MockBar(19.89, 6.36, 20.22, 6.21, numFunction)); - bars.add(new MockBar(19.28, 10.34, 20.58, 10.11, numFunction)); + data.barBuilder().openPrice(23.17).closePrice(21.48).highPrice(23.39).lowPrice(21.35).add(); + data.barBuilder().openPrice(21.25).closePrice(19.94).highPrice(21.29).lowPrice(20.07).add(); + data.barBuilder().openPrice(20.08).closePrice(21.97).highPrice(24.30).lowPrice(20.01).add(); + data.barBuilder().openPrice(22.17).closePrice(20.87).highPrice(22.64).lowPrice(20.78).add(); + data.barBuilder().openPrice(21.67).closePrice(21.65).highPrice(22.80).lowPrice(21.59).add(); + data.barBuilder().openPrice(21.47).closePrice(22.14).highPrice(22.26).lowPrice(20.96).add(); + data.barBuilder().openPrice(22.25).closePrice(21.44).highPrice(22.31).lowPrice(21.36).add(); + data.barBuilder().openPrice(21.83).closePrice(21.67).highPrice(22.40).lowPrice(21.59).add(); + data.barBuilder().openPrice(23.09).closePrice(22.90).highPrice(23.76).lowPrice(22.73).add(); + data.barBuilder().openPrice(22.93).closePrice(22.01).highPrice(23.27).lowPrice(21.94).add(); + data.barBuilder().openPrice(19.89).closePrice(19.20).highPrice(20.47).lowPrice(18.91).add(); + data.barBuilder().openPrice(21.56).closePrice(18.83).highPrice(21.80).lowPrice(18.83).add(); + data.barBuilder().openPrice(19.00).closePrice(18.35).highPrice(19.41).lowPrice(18.01).add(); + data.barBuilder().openPrice(19.89).closePrice(6.36).highPrice(20.22).lowPrice(6.21).add(); + data.barBuilder().openPrice(19.28).closePrice(10.34).highPrice(20.58).lowPrice(10.11).add(); - data = new MockBarSeries(bars); } @Test public void testSuperTrendUpperBandIndicator() { - SuperTrendUpperBandIndicator superTrendUpperBandIndicator = new SuperTrendUpperBandIndicator(data); + var superTrendUpperBandIndicator = new SuperTrendUpperBandIndicator(data); - assertNumEquals(this.numOf(26.610999999999997), superTrendUpperBandIndicator.getValue(1)); - assertNumEquals(this.numOf(26.610999999999997), superTrendUpperBandIndicator.getValue(6)); - assertNumEquals(this.numOf(24.67820648851259), superTrendUpperBandIndicator.getValue(12)); + assertNumEquals(numFactory.numOf(26.610999999999997), superTrendUpperBandIndicator.getValue(1)); + assertNumEquals(numFactory.numOf(26.610999999999997), superTrendUpperBandIndicator.getValue(6)); + assertNumEquals(numFactory.numOf(24.67820648851259), superTrendUpperBandIndicator.getValue(12)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicatorTest.java index bd6d65062..fca07a099 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/AccumulationDistributionIndicatorTest.java @@ -25,38 +25,29 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class AccumulationDistributionIndicatorTest extends AbstractIndicatorTest, Num> { - public AccumulationDistributionIndicatorTest(Function numFunction) { - super(numFunction); + public AccumulationDistributionIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void accumulationDistribution() { - ZonedDateTime now = ZonedDateTime.now(); - List bars = new ArrayList<>(); - bars.add(new MockBar(now, 0d, 10d, 12d, 8d, 0d, 200d, 0, numFunction));// 2-2 * 200 / 4 - bars.add(new MockBar(now, 0d, 8d, 10d, 7d, 0d, 100d, 0, numFunction));// 1-2 *100 / 3 - bars.add(new MockBar(now, 0d, 9d, 15d, 6d, 0d, 300d, 0, numFunction));// 3-6 *300 /9 - bars.add(new MockBar(now, 0d, 20d, 40d, 5d, 0d, 50d, 0, numFunction));// 15-20 *50 / 35 - bars.add(new MockBar(now, 0d, 30d, 30d, 3d, 0d, 600d, 0, numFunction));// 27-0 *600 /27 + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(10d).highPrice(12d).lowPrice(8d).volume(200d).add(); // 2-2 * 200 / 4 + series.barBuilder().closePrice(8d).highPrice(10d).lowPrice(7d).volume(100d).add(); // 1-2 *100 / 3 + series.barBuilder().closePrice(9d).highPrice(15d).lowPrice(6d).volume(300d).add(); // 3-6 *300 /9 + series.barBuilder().closePrice(20d).highPrice(40d).lowPrice(5d).volume(50d).add(); // 15-20 *50 / 35 + series.barBuilder().closePrice(30d).highPrice(30d).lowPrice(3d).volume(600d).add(); // 27-0 *600 /27 - BarSeries series = new MockBarSeries(bars); - AccumulationDistributionIndicator ac = new AccumulationDistributionIndicator(series); + var ac = new AccumulationDistributionIndicator(series); assertNumEquals(0, ac.getValue(0)); assertNumEquals(-100d / 3, ac.getValue(1)); assertNumEquals(-100d - (100d / 3), ac.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicatorTest.java index 716d2eb5a..2d2c36310 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinMoneyFlowIndicatorTest.java @@ -25,53 +25,49 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.time.ZonedDateTime; - import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class ChaikinMoneyFlowIndicatorTest { @Test public void getValue() { - ZonedDateTime now = ZonedDateTime.now(); - BarSeries series = new BaseBarSeries(); - int sec = 1000; - series.addBar(now.minusSeconds(sec--), "0", "62.34", "61.37", "62.15", "7849.025"); - series.addBar(now.minusSeconds(sec--), "0", "62.05", "60.69", "60.81", "11692.075"); - series.addBar(now.minusSeconds(sec--), "0", "62.27", "60.10", "60.45", "10575.307"); - series.addBar(now.minusSeconds(sec--), "0", "60.79", "58.61", "59.18", "13059.128"); - series.addBar(now.minusSeconds(sec--), "0", "59.93", "58.71", "59.24", "20733.508"); - series.addBar(now.minusSeconds(sec--), "0", "61.75", "59.86", "60.20", "29630.096"); - series.addBar(now.minusSeconds(sec--), "0", "60.00", "57.97", "58.48", "17705.294"); - series.addBar(now.minusSeconds(sec--), "0", "59.00", "58.02", "58.24", "7259.203"); - series.addBar(now.minusSeconds(sec--), "0", "59.07", "57.48", "58.69", "10474.629"); - series.addBar(now.minusSeconds(sec--), "0", "59.22", "58.30", "58.65", "5203.714"); - series.addBar(now.minusSeconds(sec--), "0", "58.75", "57.83", "58.47", "3422.865"); - series.addBar(now.minusSeconds(sec--), "0", "58.65", "57.86", "58.02", "3962.150"); - series.addBar(now.minusSeconds(sec--), "0", "58.47", "57.91", "58.17", "4095.905"); - series.addBar(now.minusSeconds(sec--), "0", "58.25", "57.83", "58.07", "3766.006"); - series.addBar(now.minusSeconds(sec--), "0", "58.35", "57.53", "58.13", "4239.335"); - series.addBar(now.minusSeconds(sec--), "0", "59.86", "58.58", "58.94", "8039.979"); - series.addBar(now.minusSeconds(sec--), "0", "59.53", "58.30", "59.10", "6956.717"); - series.addBar(now.minusSeconds(sec--), "0", "62.10", "58.53", "61.92", "18171.552"); - series.addBar(now.minusSeconds(sec--), "0", "62.16", "59.80", "61.37", "22225.894"); + BarSeries series = new MockBarSeriesBuilder().build(); + series.barBuilder().highPrice(62.34).lowPrice(61.37).closePrice(62.15).volume(7849.025).add(); + series.barBuilder().highPrice(62.05).lowPrice(60.69).closePrice(60.81).volume(11692.075).add(); + series.barBuilder().highPrice(62.27).lowPrice(60.10).closePrice(60.45).volume(10575.307).add(); + series.barBuilder().highPrice(60.79).lowPrice(58.61).closePrice(59.18).volume(13059.128).add(); + series.barBuilder().highPrice(59.93).lowPrice(58.71).closePrice(59.24).volume(20733.508).add(); + series.barBuilder().highPrice(61.75).lowPrice(59.86).closePrice(60.20).volume(29630.096).add(); + series.barBuilder().highPrice(60.00).lowPrice(57.97).closePrice(58.48).volume(17705.294).add(); + series.barBuilder().highPrice(59.00).lowPrice(58.02).closePrice(58.24).volume(7259.203).add(); + series.barBuilder().highPrice(59.07).lowPrice(57.48).closePrice(58.69).volume(10474.629).add(); + series.barBuilder().highPrice(59.22).lowPrice(58.30).closePrice(58.65).volume(5203.714).add(); + series.barBuilder().highPrice(58.75).lowPrice(57.83).closePrice(58.47).volume(3422.865).add(); + series.barBuilder().highPrice(58.65).lowPrice(57.86).closePrice(58.02).volume(3962.150).add(); + series.barBuilder().highPrice(58.47).lowPrice(57.91).closePrice(58.17).volume(4095.905).add(); + series.barBuilder().highPrice(58.25).lowPrice(57.83).closePrice(58.07).volume(3766.006).add(); + series.barBuilder().highPrice(58.35).lowPrice(57.53).closePrice(58.13).volume(4239.335).add(); + series.barBuilder().highPrice(59.86).lowPrice(58.58).closePrice(58.94).volume(8039.979).add(); + series.barBuilder().openPrice(0).highPrice(59.53).lowPrice(58.30).closePrice(59.10).volume(6956.717).add(); + series.barBuilder().highPrice(62.10).lowPrice(58.53).closePrice(61.92).volume(18171.552).add(); + series.barBuilder().highPrice(62.16).lowPrice(59.80).closePrice(61.37).volume(22225.894).add(); - series.addBar(now.minusSeconds(sec--), "0", "62.67", "60.93", "61.68", "14613.509"); - series.addBar(now.minusSeconds(sec--), "0", "62.38", "60.15", "62.09", "12319.763"); - series.addBar(now.minusSeconds(sec--), "0", "63.73", "62.26", "62.89", "15007.690"); - series.addBar(now.minusSeconds(sec--), "0", "63.85", "63.00", "63.53", "8879.667"); - series.addBar(now.minusSeconds(sec--), "0", "66.15", "63.58", "64.01", "22693.812"); - series.addBar(now.minusSeconds(sec--), "0", "65.34", "64.07", "64.77", "10191.814"); - series.addBar(now.minusSeconds(sec--), "0", "66.48", "65.20", "65.22", "10074.152"); - series.addBar(now.minusSeconds(sec--), "0", "65.23", "63.21", "63.28", "9411.620"); - series.addBar(now.minusSeconds(sec--), "0", "63.40", "61.88", "62.40", "10391.690"); - series.addBar(now.minusSeconds(sec--), "0", "63.18", "61.11", "61.55", "8926.512"); - series.addBar(now.minusSeconds(sec--), "0", "62.70", "61.25", "62.69", "7459.575"); + series.barBuilder().highPrice(62.67).lowPrice(60.93).closePrice(61.68).volume(14613.509).add(); + series.barBuilder().highPrice(62.38).lowPrice(60.15).closePrice(62.09).volume(12319.763).add(); + series.barBuilder().highPrice(63.73).lowPrice(62.26).closePrice(62.89).volume(15007.690).add(); + series.barBuilder().highPrice(63.85).lowPrice(63.00).closePrice(63.53).volume(8879.667).add(); + series.barBuilder().highPrice(66.15).lowPrice(63.58).closePrice(64.01).volume(22693.812).add(); + series.barBuilder().openPrice(0).highPrice(65.34).lowPrice(64.07).closePrice(64.77).volume(10191.814).add(); + series.barBuilder().highPrice(66.48).lowPrice(65.20).closePrice(65.22).volume(10074.152).add(); + series.barBuilder().highPrice(65.23).lowPrice(63.21).closePrice(63.28).volume(9411.620).add(); + series.barBuilder().highPrice(63.40).lowPrice(61.88).closePrice(62.40).volume(10391.690).add(); + series.barBuilder().highPrice(63.18).lowPrice(61.11).closePrice(61.55).volume(8926.512).add(); + series.barBuilder().highPrice(62.70).lowPrice(61.25).closePrice(62.69).volume(7459.575).add(); - ChaikinMoneyFlowIndicator cmf = new ChaikinMoneyFlowIndicator(series, 20); + var cmf = new ChaikinMoneyFlowIndicator(series, 20); assertNumEquals(0.6082, cmf.getValue(0)); assertNumEquals(-0.2484, cmf.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinOscillatorIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinOscillatorIndicatorTest.java index adc1f0546..73a646c6c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinOscillatorIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ChaikinOscillatorIndicatorTest.java @@ -25,43 +25,66 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ChaikinOscillatorIndicatorTest extends AbstractIndicatorTest, Num> { - public ChaikinOscillatorIndicatorTest(Function numFunction) { - super(numFunction); + public ChaikinOscillatorIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValue() { - List bars = new ArrayList<>(); - bars.add(new MockBar(12.915, 13.600, 12.890, 13.550, 264266, numFunction)); - bars.add(new MockBar(13.550, 13.770, 13.310, 13.505, 305427, numFunction)); - bars.add(new MockBar(13.510, 13.590, 13.425, 13.490, 104077, numFunction)); - bars.add(new MockBar(13.515, 13.545, 13.400, 13.480, 136135, numFunction)); - bars.add(new MockBar(13.490, 13.495, 13.310, 13.345, 92090, numFunction)); - bars.add(new MockBar(13.350, 13.490, 13.325, 13.420, 80948, numFunction)); - bars.add(new MockBar(13.415, 13.460, 13.290, 13.300, 82983, numFunction)); - bars.add(new MockBar(13.320, 13.320, 13.090, 13.130, 126918, numFunction)); - bars.add(new MockBar(13.145, 13.225, 13.090, 13.150, 68560, numFunction)); - bars.add(new MockBar(13.150, 13.250, 13.110, 13.245, 41178, numFunction)); - bars.add(new MockBar(13.245, 13.250, 13.120, 13.210, 63606, numFunction)); - bars.add(new MockBar(13.210, 13.275, 13.185, 13.275, 34402, numFunction)); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder() + .openPrice(12.915) + .closePrice(13.600) + .highPrice(12.890) + .lowPrice(13.550) + .volume(264266) + .add(); + series.barBuilder() + .openPrice(13.550) + .closePrice(13.770) + .highPrice(13.310) + .lowPrice(13.505) + .volume(305427) + .add(); + series.barBuilder() + .openPrice(13.510) + .closePrice(13.590) + .highPrice(13.425) + .lowPrice(13.490) + .volume(104077) + .add(); + series.barBuilder() + .openPrice(13.515) + .closePrice(13.545) + .highPrice(13.400) + .lowPrice(13.480) + .volume(136135) + .add(); + series.barBuilder().openPrice(13.490).closePrice(13.495).highPrice(13.310).lowPrice(13.345).volume(92090).add(); + series.barBuilder().openPrice(13.350).closePrice(13.490).highPrice(13.325).lowPrice(13.420).volume(80948).add(); + series.barBuilder().openPrice(13.415).closePrice(13.460).highPrice(13.290).lowPrice(13.300).volume(82983).add(); + series.barBuilder() + .openPrice(13.320) + .closePrice(13.320) + .highPrice(13.090) + .lowPrice(13.130) + .volume(126918) + .add(); + series.barBuilder().openPrice(13.145).closePrice(13.225).highPrice(13.090).lowPrice(13.150).volume(68560).add(); + series.barBuilder().openPrice(13.150).closePrice(13.250).highPrice(13.110).lowPrice(13.245).volume(41178).add(); + series.barBuilder().openPrice(13.245).closePrice(13.250).highPrice(13.120).lowPrice(13.210).volume(63606).add(); + series.barBuilder().openPrice(13.210).closePrice(13.275).highPrice(13.185).lowPrice(13.275).volume(34402).add(); - BarSeries series = new MockBarSeries(bars); - ChaikinOscillatorIndicator co = new ChaikinOscillatorIndicator(series); + var co = new ChaikinOscillatorIndicator(series); assertNumEquals(0.0, co.getValue(0)); assertNumEquals(-361315.15734265576, co.getValue(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/IIIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/IIIIndicatorTest.java index adb2eb97a..5b70abe15 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/IIIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/IIIIndicatorTest.java @@ -25,37 +25,33 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class IIIIndicatorTest extends AbstractIndicatorTest, Num> { - public IIIIndicatorTest(Function numFunction) { + public IIIIndicatorTest(NumFactory numFunction) { super(numFunction); } @Test public void intradayIntensityIndex() { - ZonedDateTime now = ZonedDateTime.now(); - List bars = new ArrayList<>(); - bars.add(new MockBar(now, 0d, 10d, 12d, 8d, 0d, 200d, 0, numFunction));// 2-2 * 200 / 4 - bars.add(new MockBar(now, 0d, 8d, 10d, 7d, 0d, 100d, 0, numFunction));// 1-2 *100 / 3 - bars.add(new MockBar(now, 0d, 9d, 15d, 6d, 0d, 300d, 0, numFunction));// 3-6 *300 /9 - bars.add(new MockBar(now, 0d, 20d, 40d, 5d, 0d, 50d, 0, numFunction));// 15-20 *50 / 35 - bars.add(new MockBar(now, 0d, 30d, 30d, 3d, 0d, 600d, 0, numFunction));// 27-0 *600 /27 + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + // 2-2 * 200 / 4 + series.barBuilder().openPrice(0d).closePrice(10d).highPrice(12d).lowPrice(8d).volume(200d).add(); + // 1-2 * 100 / 3 + series.barBuilder().openPrice(0d).closePrice(8d).highPrice(10d).lowPrice(7d).volume(100d).add(); + // 3-6 * 300 / 9 + series.barBuilder().openPrice(0d).closePrice(9d).highPrice(15d).lowPrice(6d).volume(300d).add(); + // 15-20 * 50 / 35 + series.barBuilder().openPrice(0d).closePrice(20d).highPrice(40d).lowPrice(5d).volume(50d).add(); + // 27-0 * 600 / 27 + series.barBuilder().openPrice(0d).closePrice(30d).highPrice(30d).lowPrice(3d).volume(600d).add(); - BarSeries series = new MockBarSeries(bars); - IIIIndicator iiiIndicator = new IIIIndicator(series); + var iiiIndicator = new IIIIndicator(series); assertNumEquals(0, iiiIndicator.getValue(0)); assertNumEquals((2 * 8d - 10d - 7d) / ((10d - 7d) * 100d), iiiIndicator.getValue(1)); assertNumEquals((2 * 9d - 15d - 6d) / ((15d - 6d) * 300d), iiiIndicator.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MVWAPIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MVWAPIndicatorTest.java index 56e239dce..e691bbb41 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MVWAPIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MVWAPIndicatorTest.java @@ -25,52 +25,46 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class MVWAPIndicatorTest extends AbstractIndicatorTest, Num> { protected BarSeries data; - public MVWAPIndicatorTest(Function numFunction) { - super(numFunction); + public MVWAPIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, 1, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, 2, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, 1, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, 3, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, 1, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, 2, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, 1, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, 5, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, 1, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, 1, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, 1, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, 5, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, 7, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, 6, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, 1, numFunction)); - bars.add(new MockBar(44.23, 43.95, 44.29, 43.81, 2, numFunction)); - bars.add(new MockBar(43.91, 43.08, 43.99, 43.08, 1, numFunction)); - bars.add(new MockBar(43.07, 43.55, 43.65, 43.06, 7, numFunction)); - bars.add(new MockBar(43.56, 43.95, 43.99, 43.53, 6, numFunction)); - bars.add(new MockBar(43.93, 44.47, 44.58, 43.93, 1, numFunction)); - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).volume(1).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).volume(2).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).volume(1).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).volume(3).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).volume(1).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).volume(2).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).volume(1).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).volume(5).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).volume(1).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).volume(1).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).volume(1).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).volume(5).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).volume(7).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).volume(6).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).volume(1).add(); + data.barBuilder().openPrice(44.23).closePrice(43.95).highPrice(44.29).lowPrice(43.81).volume(2).add(); + data.barBuilder().openPrice(43.91).closePrice(43.08).highPrice(43.99).lowPrice(43.08).volume(1).add(); + data.barBuilder().openPrice(43.07).closePrice(43.55).highPrice(43.65).lowPrice(43.06).volume(7).add(); + data.barBuilder().openPrice(43.56).closePrice(43.95).highPrice(43.99).lowPrice(43.53).volume(6).add(); + data.barBuilder().openPrice(43.93).closePrice(44.47).highPrice(44.58).lowPrice(43.93).volume(1).add(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicatorTest.java index 37e9a0686..cc38666e2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/MoneyFlowIndexIndicatorTest.java @@ -23,46 +23,35 @@ */ package org.ta4j.core.indicators.volume; -import org.junit.Ignore; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.ta4j.core.TestUtils.assertNumEquals; + import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.NaN; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; - -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - -import static org.junit.Assert.*; -import static org.ta4j.core.TestUtils.assertNumEquals; -import static org.ta4j.core.num.NaN.NaN; +import org.ta4j.core.num.NumFactory; public class MoneyFlowIndexIndicatorTest extends AbstractIndicatorTest, Num> { - public MoneyFlowIndexIndicatorTest(Function numFunction) { - super(numFunction); + public MoneyFlowIndexIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { - List bars = new ArrayList<>(); - bars.add(new MockBar(10, 10, 10, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(9, 9, 9, 9, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - BarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().build(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(0).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(9).closePrice(9).highPrice(9).lowPrice(9).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); - MoneyFlowIndexIndicator mfi = new MoneyFlowIndexIndicator(series, 5); + var mfi = new MoneyFlowIndexIndicator(series, 5); assertTrue(mfi.getValue(0).isNaN()); assertTrue(mfi.getValue(1).isNaN()); @@ -74,17 +63,16 @@ public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { @Test public void givenBarCountOf1_whenGetValue_thenReturnEdgeCaseCorrectedValue() { - List bars = new ArrayList<>(); - bars.add(new MockBar(10, 10, 10, 10, numFunction)); - bars.add(new MockBar(9, 9, 9, 9, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(12, 12, 12, 12, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - BarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().build(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(0).add(); + series.barBuilder().openPrice(9).closePrice(9).highPrice(9).lowPrice(9).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(12).closePrice(12).highPrice(12).lowPrice(12).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); - MoneyFlowIndexIndicator mfi = new MoneyFlowIndexIndicator(series, 1); + var mfi = new MoneyFlowIndexIndicator(series, 1); assertTrue(mfi.getValue(0).isNaN()); assertNumEquals(1.098901098901095, mfi.getValue(1)); @@ -96,18 +84,17 @@ public void givenBarCountOf1_whenGetValue_thenReturnEdgeCaseCorrectedValue() { @Test public void givenBarCountOf3_whenGetValue_thenReturnCorrectValue() { - List bars = new ArrayList<>(); - bars.add(new MockBar(10, 10, 10, 10, numFunction)); - bars.add(new MockBar(9, 9, 9, 9, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(12, 12, 12, 12, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(12, 12, 12, 12, 10, numFunction)); - bars.add(new MockBar(9, 9, 9, 9, 10, numFunction)); - BarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().build(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(0).add(); + series.barBuilder().openPrice(9).closePrice(9).highPrice(9).lowPrice(9).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(12).closePrice(12).highPrice(12).lowPrice(12).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(12).closePrice(12).highPrice(12).lowPrice(12).volume(10).add(); + series.barBuilder().openPrice(9).closePrice(9).highPrice(9).lowPrice(9).volume(10).add(); - MoneyFlowIndexIndicator mfi = new MoneyFlowIndexIndicator(series, 3); + var mfi = new MoneyFlowIndexIndicator(series, 3); assertTrue(mfi.getValue(0).isNaN()); assertTrue(mfi.getValue(1).isNaN()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/NVIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/NVIIndicatorTest.java index 594f8eea7..69e86e5d7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/NVIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/NVIIndicatorTest.java @@ -25,42 +25,34 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class NVIIndicatorTest extends AbstractIndicatorTest, Num> { - public NVIIndicatorTest(Function numFunction) { - super(numFunction); + public NVIIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValue() { + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(1355.69).volume(2739.55).add(); + series.barBuilder().closePrice(1325.51).volume(3119.46).add(); + series.barBuilder().closePrice(1335.02).volume(3466.88).add(); + series.barBuilder().closePrice(1313.72).volume(2577.12).add(); + series.barBuilder().closePrice(1319.99).volume(2480.45).add(); + series.barBuilder().closePrice(1331.85).volume(2329.79).add(); + series.barBuilder().closePrice(1329.04).volume(2793.07).add(); + series.barBuilder().closePrice(1362.16).volume(3378.78).add(); + series.barBuilder().closePrice(1365.51).volume(2417.59).add(); + series.barBuilder().closePrice(1374.02).volume(1442.81).add(); - List bars = new ArrayList(); - bars.add(new MockBar(1355.69, 2739.55, numFunction)); - bars.add(new MockBar(1325.51, 3119.46, numFunction)); - bars.add(new MockBar(1335.02, 3466.88, numFunction)); - bars.add(new MockBar(1313.72, 2577.12, numFunction)); - bars.add(new MockBar(1319.99, 2480.45, numFunction)); - bars.add(new MockBar(1331.85, 2329.79, numFunction)); - bars.add(new MockBar(1329.04, 2793.07, numFunction)); - bars.add(new MockBar(1362.16, 3378.78, numFunction)); - bars.add(new MockBar(1365.51, 2417.59, numFunction)); - bars.add(new MockBar(1374.02, 1442.81, numFunction)); - BarSeries series = new MockBarSeries(bars); - - NVIIndicator nvi = new NVIIndicator(series); + var nvi = new NVIIndicator(series); assertNumEquals(1000, nvi.getValue(0)); assertNumEquals(1000, nvi.getValue(1)); assertNumEquals(1000, nvi.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicatorTest.java index 9b54e4956..45ac5ddba 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/OnBalanceVolumeIndicatorTest.java @@ -25,37 +25,30 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class OnBalanceVolumeIndicatorTest extends AbstractIndicatorTest, Num> { - public OnBalanceVolumeIndicatorTest(Function numFunction) { - super(numFunction); + public OnBalanceVolumeIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValue() { - ZonedDateTime now = ZonedDateTime.now(); - List bars = new ArrayList<>(); - bars.add(new MockBar(now, 0, 10, 0, 0, 0, 4, 0, numFunction)); - bars.add(new MockBar(now, 0, 5, 0, 0, 0, 2, 0, numFunction)); - bars.add(new MockBar(now, 0, 6, 0, 0, 0, 3, 0, numFunction)); - bars.add(new MockBar(now, 0, 7, 0, 0, 0, 8, 0, numFunction)); - bars.add(new MockBar(now, 0, 7, 0, 0, 0, 6, 0, numFunction)); - bars.add(new MockBar(now, 0, 6, 0, 0, 0, 10, 0, numFunction)); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(10).volume(4).add(); + series.barBuilder().closePrice(5).volume(2).add(); + series.barBuilder().closePrice(6).volume(3).add(); + series.barBuilder().closePrice(7).volume(8).add(); + series.barBuilder().closePrice(7).volume(6).add(); + series.barBuilder().closePrice(6).volume(10).add(); - OnBalanceVolumeIndicator obv = new OnBalanceVolumeIndicator(new MockBarSeries(bars)); + var obv = new OnBalanceVolumeIndicator(series); assertNumEquals(0, obv.getValue(0)); assertNumEquals(-2, obv.getValue(1)); assertNumEquals(1, obv.getValue(2)); @@ -65,13 +58,12 @@ public void getValue() { } @Test - public void stackOverflowError() { - List bigListOfBars = new ArrayList(); + public void noStackOverflowError() { + var bigSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); for (int i = 0; i < 10000; i++) { - bigListOfBars.add(new MockBar(i, numFunction)); + bigSeries.barBuilder().closePrice(i).volume(0).add(); } - MockBarSeries bigSeries = new MockBarSeries(bigListOfBars); - OnBalanceVolumeIndicator obv = new OnBalanceVolumeIndicator(bigSeries); + var obv = new OnBalanceVolumeIndicator(bigSeries); // If a StackOverflowError is thrown here, then the RecursiveCachedIndicator // does not work as intended. assertNumEquals(0, obv.getValue(9999)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/PVIIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/PVIIndicatorTest.java index a80d97988..ce6c88b95 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/PVIIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/PVIIndicatorTest.java @@ -25,42 +25,35 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Test; -import org.ta4j.core.Bar; -import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class PVIIndicatorTest extends AbstractIndicatorTest, Num> { - public PVIIndicatorTest(Function numFunction) { - super(numFunction); + public PVIIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Test public void getValue() { - List bars = new ArrayList(); - bars.add(new MockBar(1355.69, 2739.55, numFunction)); - bars.add(new MockBar(1325.51, 3119.46, numFunction)); - bars.add(new MockBar(1335.02, 3466.88, numFunction)); - bars.add(new MockBar(1313.72, 2577.12, numFunction)); - bars.add(new MockBar(1319.99, 2480.45, numFunction)); - bars.add(new MockBar(1331.85, 2329.79, numFunction)); - bars.add(new MockBar(1329.04, 2793.07, numFunction)); - bars.add(new MockBar(1362.16, 3378.78, numFunction)); - bars.add(new MockBar(1365.51, 2417.59, numFunction)); - bars.add(new MockBar(1374.02, 1442.81, numFunction)); - BarSeries series = new MockBarSeries(bars); + var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(1355.69).volume(2739.55).add(); + series.barBuilder().closePrice(1325.51).volume(3119.46).add(); + series.barBuilder().closePrice(1335.02).volume(3466.88).add(); + series.barBuilder().closePrice(1313.72).volume(2577.12).add(); + series.barBuilder().closePrice(1319.99).volume(2480.45).add(); + series.barBuilder().closePrice(1331.85).volume(2329.79).add(); + series.barBuilder().closePrice(1329.04).volume(2793.07).add(); + series.barBuilder().closePrice(1362.16).volume(3378.78).add(); + series.barBuilder().closePrice(1365.51).volume(2417.59).add(); + series.barBuilder().closePrice(1374.02).volume(1442.81).add(); - PVIIndicator pvi = new PVIIndicator(series); + var pvi = new PVIIndicator(series); assertNumEquals(1000, pvi.getValue(0)); assertNumEquals(977.7383, pvi.getValue(1)); assertNumEquals(984.7532, pvi.getValue(2)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ROCVIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ROCVIndicatorTest.java index 7901f5a75..242da00df 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ROCVIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/ROCVIndicatorTest.java @@ -25,42 +25,36 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class ROCVIndicatorTest extends AbstractIndicatorTest, Num> { BarSeries series; - public ROCVIndicatorTest(Function numFunction) { - super(numFunction); + public ROCVIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList(); - bars.add(new MockBar(1355.69, 1000, numFunction)); - bars.add(new MockBar(1325.51, 3000, numFunction)); - bars.add(new MockBar(1335.02, 3500, numFunction)); - bars.add(new MockBar(1313.72, 2200, numFunction)); - bars.add(new MockBar(1319.99, 2300, numFunction)); - bars.add(new MockBar(1331.85, 200, numFunction)); - bars.add(new MockBar(1329.04, 2700, numFunction)); - bars.add(new MockBar(1362.16, 5000, numFunction)); - bars.add(new MockBar(1365.51, 1000, numFunction)); - bars.add(new MockBar(1374.02, 2500, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().closePrice(1355.69).volume(1000).add(); + series.barBuilder().closePrice(1325.51).volume(3000).add(); + series.barBuilder().closePrice(1335.02).volume(3500).add(); + series.barBuilder().closePrice(1313.72).volume(2200).add(); + series.barBuilder().closePrice(1319.99).volume(2300).add(); + series.barBuilder().closePrice(1331.85).volume(200).add(); + series.barBuilder().closePrice(1329.04).volume(2700).add(); + series.barBuilder().closePrice(1362.16).volume(5000).add(); + series.barBuilder().closePrice(1365.51).volume(1000).add(); + series.barBuilder().closePrice(1374.02).volume(2500).add(); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/RelativeVolumeStandardDeviationIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/RelativeVolumeStandardDeviationIndicatorTest.java index afdc7a2aa..642456779 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/RelativeVolumeStandardDeviationIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/RelativeVolumeStandardDeviationIndicatorTest.java @@ -23,54 +23,46 @@ */ package org.ta4j.core.indicators.volume; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.ta4j.core.TestUtils.assertNumEquals; +import static org.ta4j.core.num.NaN.NaN; + import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; - -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.ta4j.core.TestUtils.assertNumEquals; -import static org.ta4j.core.num.NaN.NaN; +import org.ta4j.core.num.NumFactory; public class RelativeVolumeStandardDeviationIndicatorTest extends AbstractIndicatorTest, Num> { - private List mockBarList; private BarSeries mockBarSeries; - public RelativeVolumeStandardDeviationIndicatorTest(Function numFunction) { + public RelativeVolumeStandardDeviationIndicatorTest(NumFactory numFunction) { super(numFunction); } @Before public void setUp() { - mockBarList = new ArrayList<>(); - mockBarList.add(new MockBar(10, 9, 10, 9, 10, numFunction)); - mockBarList.add(new MockBar(10, 11, 11, 10, 11, numFunction)); - mockBarList.add(new MockBar(11, 12, 12, 10, 12, numFunction)); - mockBarList.add(new MockBar(10, 12, 12, 10, 13, numFunction)); - mockBarList.add(new MockBar(9, 12, 12, 9, 11, numFunction)); - mockBarList.add(new MockBar(9, 8, 9, 8, 10, numFunction)); - mockBarList.add(new MockBar(11, 8, 11, 8, 12, numFunction)); - mockBarList.add(new MockBar(10, 13, 13, 9, 15, numFunction)); - mockBarList.add(new MockBar(11, 2, 11, 2, 12, numFunction)); + mockBarSeries = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + mockBarSeries.barBuilder().openPrice(10).closePrice(9).highPrice(10).lowPrice(9).volume(10).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(11).highPrice(11).lowPrice(10).volume(11).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(12).highPrice(12).lowPrice(10).volume(12).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(12).highPrice(12).lowPrice(10).volume(13).add(); + mockBarSeries.barBuilder().openPrice(9).closePrice(12).highPrice(12).lowPrice(9).volume(11).add(); + mockBarSeries.barBuilder().openPrice(9).closePrice(8).highPrice(9).lowPrice(8).volume(10).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(8).highPrice(11).lowPrice(8).volume(12).add(); + mockBarSeries.barBuilder().openPrice(10).closePrice(13).highPrice(13).lowPrice(9).volume(15).add(); + mockBarSeries.barBuilder().openPrice(11).closePrice(2).highPrice(11).lowPrice(2).volume(12).add(); - mockBarSeries = new MockBarSeries(mockBarList); } @Test public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { - RelativeVolumeStandardDeviationIndicator subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, - 5); + var subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, 5); assertTrue(subject.getValue(0).isNaN()); assertTrue(subject.getValue(1).isNaN()); @@ -82,8 +74,7 @@ public void givenBarCount_whenGetValueForIndexWithinBarCount_thenReturnNaN() { @Test public void givenBarCountOf2_whenGetValue_thenReturnCorrectValue() { - RelativeVolumeStandardDeviationIndicator subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, - 2); + var subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, 2); assertTrue(subject.getValue(0).isNaN()); assertNumEquals(NaN, subject.getValue(1)); @@ -98,8 +89,7 @@ public void givenBarCountOf2_whenGetValue_thenReturnCorrectValue() { @Test public void givenBarCountOf3_whenGetValue_thenReturnCorrectValue() { - RelativeVolumeStandardDeviationIndicator subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, - 3); + var subject = new RelativeVolumeStandardDeviationIndicator(mockBarSeries, 3); assertTrue(subject.getValue(0).isNaN()); assertTrue(subject.getValue(1).isNaN()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicatorTest.java index d29f6d9fa..7457846ab 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/TimeSegmentedVolumeIndicatorTest.java @@ -23,48 +23,43 @@ */ package org.ta4j.core.indicators.volume; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.ta4j.core.TestUtils.assertNumEquals; + import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; - -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.ta4j.core.TestUtils.assertNumEquals; +import org.ta4j.core.num.NumFactory; public class TimeSegmentedVolumeIndicatorTest extends AbstractIndicatorTest, Num> { private BarSeries series; - public TimeSegmentedVolumeIndicatorTest(Function numFunction) { - super(numFunction); + public TimeSegmentedVolumeIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - List bars = new ArrayList<>(); - bars.add(new MockBar(10, 10, 10, 10, numFunction)); - bars.add(new MockBar(9, 9, 9, 9, 10, numFunction)); - bars.add(new MockBar(10, 10, 10, 10, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(12, 12, 12, 12, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - bars.add(new MockBar(11, 11, 11, 11, 10, numFunction)); - series = new MockBarSeries(bars); + series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(0).add(); + series.barBuilder().openPrice(9).closePrice(9).highPrice(9).lowPrice(9).volume(10).add(); + series.barBuilder().openPrice(10).closePrice(10).highPrice(10).lowPrice(10).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(12).closePrice(12).highPrice(12).lowPrice(12).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); + series.barBuilder().openPrice(11).closePrice(11).highPrice(11).lowPrice(11).volume(10).add(); } @Test public void whenIndexIsLessThanBarCount_returnNaN() { - TimeSegmentedVolumeIndicator tsv = new TimeSegmentedVolumeIndicator(series, 5); + var tsv = new TimeSegmentedVolumeIndicator(series, 5); assertTrue(tsv.getValue(0).isNaN()); assertTrue(tsv.getValue(1).isNaN()); @@ -76,7 +71,7 @@ public void whenIndexIsLessThanBarCount_returnNaN() { @Test public void whenBarCountIsOne_returnCorrectValue() { - TimeSegmentedVolumeIndicator tsv = new TimeSegmentedVolumeIndicator(series, 1); + var tsv = new TimeSegmentedVolumeIndicator(series, 1); assertTrue(tsv.getValue(0).isNaN()); assertNumEquals(-10, tsv.getValue(1)); @@ -88,7 +83,7 @@ public void whenBarCountIsOne_returnCorrectValue() { @Test public void whenBarCountIsThree_returnCorrectValue() { - TimeSegmentedVolumeIndicator tsv = new TimeSegmentedVolumeIndicator(series, 3); + var tsv = new TimeSegmentedVolumeIndicator(series, 3); assertTrue(tsv.getValue(0).isNaN()); assertTrue(tsv.getValue(1).isNaN()); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/VWAPIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/VWAPIndicatorTest.java index bcf8a0b78..80c23620b 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/VWAPIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/volume/VWAPIndicatorTest.java @@ -25,59 +25,52 @@ import static org.ta4j.core.TestUtils.assertNumEquals; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class VWAPIndicatorTest extends AbstractIndicatorTest, Num> { protected BarSeries data; - public VWAPIndicatorTest(Function numFunction) { - super(numFunction); + public VWAPIndicatorTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - // @TODO add volumes - List bars = new ArrayList(); - bars.add(new MockBar(44.98, 45.05, 45.17, 44.96, numFunction)); - bars.add(new MockBar(45.05, 45.10, 45.15, 44.99, numFunction)); - bars.add(new MockBar(45.11, 45.19, 45.32, 45.11, numFunction)); - bars.add(new MockBar(45.19, 45.14, 45.25, 45.04, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.14, 45.20, 45.10, numFunction)); - bars.add(new MockBar(45.13, 45.10, 45.16, 45.07, numFunction)); - bars.add(new MockBar(45.12, 45.15, 45.22, 45.10, numFunction)); - bars.add(new MockBar(45.15, 45.22, 45.27, 45.14, numFunction)); - bars.add(new MockBar(45.24, 45.43, 45.45, 45.20, numFunction)); - bars.add(new MockBar(45.43, 45.44, 45.50, 45.39, numFunction)); - bars.add(new MockBar(45.43, 45.55, 45.60, 45.35, numFunction)); - bars.add(new MockBar(45.58, 45.55, 45.61, 45.39, numFunction)); - bars.add(new MockBar(45.45, 45.01, 45.55, 44.80, numFunction)); - bars.add(new MockBar(45.03, 44.23, 45.04, 44.17, numFunction)); - bars.add(new MockBar(44.23, 43.95, 44.29, 43.81, numFunction)); - bars.add(new MockBar(43.91, 43.08, 43.99, 43.08, numFunction)); - bars.add(new MockBar(43.07, 43.55, 43.65, 43.06, numFunction)); - bars.add(new MockBar(43.56, 43.95, 43.99, 43.53, numFunction)); - bars.add(new MockBar(43.93, 44.47, 44.58, 43.93, numFunction)); - data = new MockBarSeries(bars); + data = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + data.barBuilder().openPrice(44.98).closePrice(45.05).highPrice(45.17).lowPrice(44.96).volume(1).add(); + data.barBuilder().openPrice(45.05).closePrice(45.10).highPrice(45.15).lowPrice(44.99).volume(1).add(); + data.barBuilder().openPrice(45.11).closePrice(45.19).highPrice(45.32).lowPrice(45.11).volume(1).add(); + data.barBuilder().openPrice(45.19).closePrice(45.14).highPrice(45.25).lowPrice(45.04).volume(1).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.20).lowPrice(45.10).volume(1).add(); + data.barBuilder().openPrice(45.15).closePrice(45.14).highPrice(45.20).lowPrice(45.10).volume(1).add(); + data.barBuilder().openPrice(45.13).closePrice(45.10).highPrice(45.16).lowPrice(45.07).volume(1).add(); + data.barBuilder().openPrice(45.12).closePrice(45.15).highPrice(45.22).lowPrice(45.10).volume(1).add(); + data.barBuilder().openPrice(45.15).closePrice(45.22).highPrice(45.27).lowPrice(45.14).volume(1).add(); + data.barBuilder().openPrice(45.24).closePrice(45.43).highPrice(45.45).lowPrice(45.20).volume(1).add(); + data.barBuilder().openPrice(45.43).closePrice(45.44).highPrice(45.50).lowPrice(45.39).volume(1).add(); + data.barBuilder().openPrice(45.43).closePrice(45.55).highPrice(45.60).lowPrice(45.35).volume(1).add(); + data.barBuilder().openPrice(45.58).closePrice(45.55).highPrice(45.61).lowPrice(45.39).volume(1).add(); + data.barBuilder().openPrice(45.45).closePrice(45.01).highPrice(45.55).lowPrice(44.80).volume(1).add(); + data.barBuilder().openPrice(45.03).closePrice(44.23).highPrice(45.04).lowPrice(44.17).volume(1).add(); + data.barBuilder().openPrice(44.23).closePrice(43.95).highPrice(44.29).lowPrice(43.81).volume(1).add(); + data.barBuilder().openPrice(43.91).closePrice(43.08).highPrice(43.99).lowPrice(43.08).volume(1).add(); + data.barBuilder().openPrice(43.07).closePrice(43.55).highPrice(43.65).lowPrice(43.06).volume(1).add(); + data.barBuilder().openPrice(43.56).closePrice(43.95).highPrice(43.99).lowPrice(43.53).volume(1).add(); + data.barBuilder().openPrice(43.93).closePrice(44.47).highPrice(44.58).lowPrice(43.93).volume(1).add(); } @Test public void vwap() { - VWAPIndicator vwap = new VWAPIndicator(data, 5); + var vwap = new VWAPIndicator(data, 5); assertNumEquals(45.1453, vwap.getValue(5)); assertNumEquals(45.1513, vwap.getValue(6)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java new file mode 100644 index 000000000..06d511201 --- /dev/null +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java @@ -0,0 +1,45 @@ +package org.ta4j.core.mocks; + +import java.time.Duration; +import java.time.ZonedDateTime; + +import org.ta4j.core.BaseBar; +import org.ta4j.core.BaseBarConvertibleBuilder; +import org.ta4j.core.num.NumFactory; + +/** + * @author Lukáš Kvídera + */ +public class MockBarBuilder extends BaseBarConvertibleBuilder { + + private boolean periodSet; + private boolean endTimeSet; + + public MockBarBuilder(NumFactory numFactory) { + super(numFactory); + } + + @Override + public BaseBarConvertibleBuilder endTime(final ZonedDateTime endTime) { + endTimeSet = true; + return super.endTime(endTime); + } + + @Override + public BaseBarConvertibleBuilder timePeriod(final Duration timePeriod) { + periodSet = true; + return super.timePeriod(timePeriod); + } + + @Override + public BaseBar build() { + if (!periodSet) { + timePeriod(Duration.ofDays(1)); + } + + if (!endTimeSet) { + endTime(ZonedDateTime.now()); + } + return super.build(); + } +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java new file mode 100644 index 000000000..815337dce --- /dev/null +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java @@ -0,0 +1,15 @@ +package org.ta4j.core.mocks; + +import org.ta4j.core.BarBuilderFactory; +import org.ta4j.core.BarSeries; +import org.ta4j.core.BaseBarConvertibleBuilder; + +/** + * @author Lukáš Kvídera + */ +public class MockBarBuilderFactory implements BarBuilderFactory { + @Override + public BaseBarConvertibleBuilder createBarBuilder(final BarSeries series) { + return new MockBarBuilder(series.numFactory()).bindTo(series); + } +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeries.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeries.java deleted file mode 100644 index 36f49c761..000000000 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeries.java +++ /dev/null @@ -1,110 +0,0 @@ -/** - * The MIT License (MIT) - * - * Copyright (c) 2017-2023 Ta4j Organization & respective - * authors (see AUTHORS) - * - * Permission is hereby granted, free of charge, to any person obtaining a copy of - * this software and associated documentation files (the "Software"), to deal in - * the Software without restriction, including without limitation the rights to - * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of - * the Software, and to permit persons to whom the Software is furnished to do so, - * subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR - * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER - * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -package org.ta4j.core.mocks; - -import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; - -import org.ta4j.core.Bar; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.num.Num; - -/** - * A bar series with sample data. TODO: add Builder - */ -public class MockBarSeries extends BaseBarSeries { - - private static final long serialVersionUID = -1216549934945189371L; - - public MockBarSeries(Function nf, double... data) { - super(doublesToBars(nf, data)); - } - - public MockBarSeries(Function nf, List data) { - super(doublesToBars(nf, data)); - } - - public MockBarSeries(List bars) { - super(bars); - } - - public MockBarSeries(Function nf, double[] data, ZonedDateTime[] times) { - super(doublesAndTimesToBars(nf, data, times)); - } - - public MockBarSeries(Function nf, ZonedDateTime... dates) { - super(timesToBars(nf, dates)); - } - - public MockBarSeries(Function nf) { - super(arbitraryBars(nf)); - } - - private static List doublesToBars(Function nf, List data) { - ArrayList bars = new ArrayList<>(); - for (int i = 0; i < data.size(); i++) { - bars.add(new MockBar(ZonedDateTime.now().minusSeconds((data.size() + 1 - i)), data.get(i), nf)); - } - return bars; - } - - private static List doublesToBars(Function nf, double... data) { - ArrayList bars = new ArrayList<>(); - for (int i = 0; i < data.length; i++) { - bars.add(new MockBar(ZonedDateTime.now().minusSeconds((data.length + 1 - i)), data[i], nf)); - } - return bars; - } - - private static List doublesAndTimesToBars(Function nf, double[] data, ZonedDateTime[] times) { - if (data.length != times.length) { - throw new IllegalArgumentException(); - } - ArrayList bars = new ArrayList<>(); - for (int i = 0; i < data.length; i++) { - bars.add(new MockBar(times[i], data[i], nf)); - } - return bars; - } - - private static List timesToBars(Function nf, ZonedDateTime... dates) { - ArrayList bars = new ArrayList<>(); - int i = 1; - for (ZonedDateTime date : dates) { - bars.add(new MockBar(date, i++, nf)); - } - return bars; - } - - private static List arbitraryBars(Function nf) { - ArrayList bars = new ArrayList<>(); - for (double i = 0d; i < 5000; i++) { - bars.add(new MockBar(ZonedDateTime.now().minusMinutes((long) (5001 - i)), i, i + 1, i + 2, i + 3, i + 4, - i + 5, (int) (i + 6), nf)); - } - return bars; - } -} diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java new file mode 100644 index 000000000..0a63b54a7 --- /dev/null +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -0,0 +1,91 @@ +package org.ta4j.core.mocks; + +import java.time.ZonedDateTime; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.DoubleStream; + +import org.ta4j.core.BarSeries; +import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; + +/** + * @author Lukáš Kvídera + */ +public class MockBarSeriesBuilder extends BaseBarSeriesBuilder { + + private List data; + private boolean defaultData; + + public MockBarSeriesBuilder withNumFactory(final NumFactory numFactory) { + super.withNumFactory(numFactory); + return this; + } + + /** + * Generates bars with given close prices. + * + * @param data close prices + * @return this + */ + public MockBarSeriesBuilder withData(final List data) { + this.data = data; + return this; + } + + /** + * Generates bars with given close prices. + * + * @param data close prices + * @return this + */ + public MockBarSeriesBuilder withData(final double... data) { + withData(DoubleStream.of(data).boxed().collect(Collectors.toList())); + return this; + } + + private static void doublesToBars(final BarSeries series, final List data) { + for (int i = 0; i < data.size(); i++) { + series.barBuilder() + .endTime(ZonedDateTime.now().minusSeconds((data.size() + 1 - i))) + .closePrice(data.get(i)) + .openPrice(0) + .add(); + } + } + + public MockBarSeriesBuilder withDefaultData() { + this.defaultData = true; + return this; + } + + private static void arbitraryBars(final BarSeries series) { + for (double i = 0d; i < 5000; i++) { + series.barBuilder() + .endTime(ZonedDateTime.now().minusMinutes((long) (5001 - i))) + .openPrice(i) + .closePrice(i + 1) + .highPrice(i + 2) + .lowPrice(i + 3) + .volume(i + 4) + .amount(i + 5) + .trades((int) (i + 6)) + .add(); + } + } + + @Override + public BaseBarSeries build() { + withBarBuilderFactory(new MockBarBuilderFactory()); + + final var series = super.build(); + if (this.data != null) { + doublesToBars(series, this.data); + } + if (this.defaultData) { + arbitraryBars(series); + } + return series; + } +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockIndicator.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockIndicator.java index a902e310a..a26e6ed0c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockIndicator.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockIndicator.java @@ -70,10 +70,4 @@ public int getUnstableBars() { public BarSeries getBarSeries() { return series; } - - @Override - public Num numOf(Number number) { - return series.numOf(number); - } - } diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java index 2e3a96e10..773e37159 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java @@ -24,7 +24,7 @@ package org.ta4j.core.num; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; import static org.ta4j.core.TestUtils.assertIndicatorEquals; import static org.ta4j.core.TestUtils.assertIndicatorNotEquals; import static org.ta4j.core.TestUtils.assertNumEquals; @@ -32,14 +32,9 @@ import java.math.BigDecimal; import java.time.Duration; import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.function.Function; import org.junit.Test; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.RSIIndicator; @@ -79,12 +74,42 @@ public class DecimalNumTest { // override the auto-precision based on length of SUPER_PRECISION_STRING by // passing a precision to valueOf() - private final Function superPrecisionFunc = (number -> DecimalNum.valueOf(number.toString(), 256)); + private final NumFactory superPrecisionFunc = new DecimalNumFactory() { + @Override + public Num numOf(final Number number) { + return DecimalNum.valueOf(number.toString(), 256); + } + + @Override + public Num numOf(final String number) { + return DecimalNum.valueOf(number, 256); + } + }; // auto-set precision based on length of SUPER_PRECISION_STRING (120) - private final Function precisionFunc = DecimalNum::valueOf; - private final Function precision32Func = (number -> DecimalNum.valueOf(number.toString(), 32)); - private final Function doubleFunc = DoubleNum::valueOf; - private final Function lowPrecisionFunc = (number -> DecimalNum.valueOf(number.toString(), 3)); + private final NumFactory precisionFunc = new DecimalNumFactory(); + private final NumFactory precision32Func = new DecimalNumFactory() { + @Override + public Num numOf(final Number number) { + return DecimalNum.valueOf(number.toString(), 32); + } + + @Override + public Num numOf(final String number) { + return DecimalNum.valueOf(number, 32); + } + }; + private final NumFactory doubleFunc = new DoubleNumFactory(); + private final NumFactory lowPrecisionFunc = new DecimalNumFactory() { + @Override + public Num numOf(final Number number) { + return DecimalNum.valueOf(number.toString(), 3); + } + + @Override + public Num numOf(final String number) { + return DecimalNum.valueOf(number, 3); + } + }; private BarSeries superPrecisionSeries; private BarSeries precisionSeries; @@ -100,16 +125,16 @@ public class DecimalNumTest { @Test(expected = ArithmeticException.class) public void testPowOverflowExponent() { - Num x = DecimalNum.valueOf("2"); - Num n = DecimalNum.valueOf(SUPER_PRECISION_LARGE_STRING); + final Num x = DecimalNum.valueOf("2"); + final Num n = DecimalNum.valueOf(SUPER_PRECISION_LARGE_STRING); assertNumEquals("1", x.pow(n)); } @Test public void testPowLargeBase() { - Num x = DecimalNum.valueOf(SUPER_PRECISION_STRING); - Num n = DecimalNum.valueOf("512"); - Num result = x.pow(n); + final Num x = DecimalNum.valueOf(SUPER_PRECISION_STRING); + final Num n = DecimalNum.valueOf("512"); + final Num result = x.pow(n); assertNumEquals(DecimalNum.valueOf( "71724632698264595311439425390811606219342673848.40061398197558400628535301224325643216058951634134487681508791576999627245777743886595731790545842366554761960764715298199175003491698577211286777266293829613857304790203141652841341965933919391594071804439505157490302430762773157180552969960522864095823082873441680807544918991203869348555299690458903865314435725800329292241572202898890243426149619074137233197293302558727876625465252035629952605534054248733352420143658565066825787684456965525734073507885806971213010152950953654336699292262932953296818721212820449820087344151656553177810720848835123990382300462154832295028583939839900512827625370164949144406661074671569820237108586270109431448109725094893131604249607451409922082653728543854496396085264748558023019737395311212340360924693854937492419450793593992183367210721950721381943684242634254267400343216332964422191330212627426946750415808407451123635427594645644829139081263025663166449233830222395125965438688245956773051668954571764834787203488753789108695378538886023689560714116918022258848041890900525402045484908021088098956392705393648816334126286164670658196920876541746432442368484775047048336388959152008469612610584131056943937561048957655818367691474410289022960295903253223484219140744105021893314255674202528364264971733602723443247961598369626755987284596037693366051313253442210258917559938679001386510782542351720309935500204291971383329665310816783662223230741497715533660376607702599335320686934477100036316607503565709183224194452544482682157346389551618149788052982778263236272476905335766202314127219300308224367109649214042457366793163136717995263099845284751466528878753079679456805381707808425091170324238310245614582822777661960647728893224684239510947849549999386589805013849784343854816212984720327971396206232545120686020900405944658823610816219789490259115849498395366028624420990103520950536225025996704419109373472529379133359223742608560572841165359031562907848230885938315068983677251328318911290657387978396217029547478808009017473148996904347293564050136917528522105313100612688859303686497022403089051911372142347953251014056605807376169918491694191567441959393476814016152068596443448558253646960203048105664040908539871889250791552334558606753614826083762699843535700395488738647562623908978295635823367311979483067474111468003904327788301732675169331629848690771472842124195106786326512607393633937764585857746909874410642073978298541390431488618063910282819045304267722577211697286932606367027036680702519143095779950649400347119612072379276782470368544025487100201644627710884878510105626903621533987853041076831596330605218915452869201604048613348328260498207027258025250477541181237422773961761733047112034975540213155120014243023057843103021257187750987957463062957168946581184741684722395833973858344111672960119737555033259115241865898127616946899507053036159481091258336986967712688100897215319834337447010542503708858920241306781818719336935927022853728497752805880138837947492715738726531567831212451551324406301181773314597089534725932224083142885521596333897058966683368625094602483074384313333911167306376561226126712693720249468634377090821262603344638495465466546380399792171168775254215610829748728604184082987187063135462742752627701005737351331343179237284337919378626151957593948564065400513780731884034320984929258796803252730905279269744716069237700798534740641496155903976171633381609869131921677426693877442587613876079591014512141977868925380972912403072938138196803938303235427548262656666993630676816079370020478962939975616292241158774911227836302784103308764011516377263074607062509464683283310359618606106008996898035602081312217719381426579760477614300332648603405637798236372279224609513114683678536042433992526895914271776656220516368406360889050985405297222308107526933171234263864355602013860999646736093408836176096010537394340213094467442727061261552271985379571074217362009758549607870335184435217564352313837607103804736120936420874550683241557558724604839123919506072391316610686441850421669141132770996086286923309489606193046869099797262233309494865371884040923009566204125699497949712717515698452397583421466568479545168828385627792568134505545837794995050959018878882427732826278471594311875950448846660385679052070526246578869381712948016927397324963319711436702392156145631385531264399070737477846065364623957889922051516521475034593057693553341645030787917655352479422739827474611058673188166200655205044923426578822028995290890845723087114020293908178710668616852700631830978715734297163803293895760725365421808228118977647816351601499634070591653810033765208634582908609410932353937151488624797102481050189609687586468945302508907864665093457335327907705265481427235437389637492544059041061815395216988687388339809013014222415122198602757140818479498906141512870134273845866771028368258986267424544724510666856701219992623159708546389849674355465652858607479866018617869992305618315246808789943934597249122926036420128442313351327466248694260021123815364773348972265568466817317080133940441632528296115865614643148602621376212013537004099118041684340245215395448133045576690687257312643353584385414961935682105738160698460119275275573408698062073385982177842258985820937136940681108813125380323007296424909562618640955731396012030297757395915612693394245087761824456923034029286382818400506389668494585720475871155289285616591441479171658667957463227415553973813139138077555504335524609314570584295536909624097430278875135654302868882014322620689277095528120027100106420166737092822121468150623614009952034096107234847625604628673275103930651277363106354381902021336342982763309521429963288503558242398737264174889187451154289346715177695078515428604566827946693600296057322786438595605757051437537658458446832081449201324626180791778945951196155827898246998917170707388393812524699153369083630794221151317573954046249870199221454556718885158053874402328404477342326398655078530448722922183347450757500110629884421352442523313667136043495771147756350570609079630285158796398132958734811322194498163481479746655516176929580802776851037530010249055883003850638630146317729644701082030389142274323935167093463997902314060559933615358994228113250814924391501467141287273143033537694676250446364140591558275618348503194358571495755335114952183729191024351010274104084077389763778052696460622687935432102982491454796118820783012653494748411435130476578547431640023608350055076971650745505682793268366244283190484548152899336154240770050347494905997728715885787035742867936275991964603670444189541842417761030566110497438171204655614865191894056672046781651117288729444339057506907250086241546518737370331150610729969045305153722110139889624767828083464954779342265566680981053793311179755468325049864449801364571355439464309562956381992020106028747149509099514194849103715974725071600563967172553731794978313120099744527021774460544795787755915179949237323623596648169990050724578022192161823603950343804775641061217772641451201921259086676412466423970500349829316631991129761242128353242935743687676839663898440266932076905774917956099347121023541774976862198194787015693557125924188840819940688052218988436863675083453182656189236842417927081487222457795483025608617046200326918340609796998542501131707588205835452814232280487227930466378321160857466396712737027882813223154296556187093368009591843652712905091927304456554730547087390788612178885034627177491896782066511411003981621217903987973703916561537783384629424739746137097941135153849050250201809188508240994657729934028308207060521091027745479377263578422510750977490696806063041299728592670546005026214313773643980850333073790026814392147449023570834928091084491108094046388649930893468973054693121537729071236987928747093401630007356752435992257198407288975417769039814185089193755372572109906670437804214933043140450788584938469284603633498806240506821477646617697782450289088286792547810765996504760798925642291579595719226295153813427842793337917083272969361039695637775821799497789877665506555537868154272646841141008713651746738383295269278129112364934571554261522424596530593566532383265399733702508097308750582905385663036054017942948916395837104151603594905278871570557217627320395695028407195566153702177053185374182982426133316237967426478661367620141513886111245224238534501319053071243771336003617837537806808680710263973328313425855634077342024183192779269164685295709824418373692490578233306811877776400364382406905442702262891741012299322662644438058230759129758719236609996337983697138597324214924030133055489862444169242754427552232812278288025194543278555217632392750591113980334272784788699014048026268434783005931614928370040720278176080863026413085935697763284406853347365403601724873870732157955440377536729150795618664380891345989494809237453583437272454156579143833022321962841784027484667497460400082885627987768722107528665028161669654391437028790045498398109702652972454633004741280108636822044776903509270618034307976497559259286867376734619082819167505513966586380516505417295031414419855855965167309145399821296895330442929715867281910812788364540801800336979903474266157743586783962924490141034870523989694110899423509680194652484156390730750340990930691085310975880765545883191749266594641486022823685846683535061022258903141753722141703894903869272074925282892690416085919552686332350903328399805087723735377084136015428212861816321430780125253466522214030241137180963715359603926087724848804290704517448177145940164802930406146736706975254933298392080792336871916790381621613895118237440060735791295552730516609726465835390388966389664779652757969828388195068265395707832995526104366558469710974155788695407633235540856912282588898907628809566865898279981796385991088662125237360662570551477205676695804435731005135563585276987998248514887354439772991788613915529609986094788229393538087020518849046806600482053848581744708426684375887025650779307130033185235338912025156747246767411198879726563782687322425506394929697135958862217930680285545595306159448904208181773894223622238678342086347953999802587014247668202559329656643764834851242210851165601499047750386389661487279671229690977120711895516279492621091028376880697795674659731617411396068297541509357846792136121568196841287586205953142846786968373694263018931302895357254700191216478420535370733501911817633888871748875276606038816723895661235774624673038829559166023189904885052412054694717593861836250613303500717055772464865588309094229411608348141845860623405710148314979226897721032943751612449159121804723451560298031111089250086247941072592954407428782111173749193173607723490383182366697233150539259706730072124586962011145732336313222192702722162321226919525442262678056746056774865280301480557946374627756262315060563178665708400180768051837141121618654879957420616900167773148349727776897219954912855486929992046245497840965454867621973364824363376921546748866179548789499573692116797133683217604285142072540777653486331265825048801768337880077660561967043880008614856418723955124445194386426222938834374394239809548659890515191353646461737267901933251447477600189286931225692703990782103557127032514897061521639432116426292289158150966785535513599620790764947113719541707226142516585881244178696159368145453873584074425851675571359107520201406604646928729802062349877350034310746477862403674368842648540005266753850453323232906673598752323779320282691243158065315177307008513595161462704688029248982509608925354822345423961472926679336335212120943178232660766399514062500645614078588560146372192803507965927799542420407394851750546451873326382115558871963138955488271049137091376432548358576252575371933302173149014121414811214354976474813886765380145534090119828088060750867769710335253343282174148151683596345063238268356712079255739698555775701451620314319401222066692800751080824534869408497519698997634393553057807606693836882807518365634533711424045716453091713282690280986082107480239377232318566260615657861673726148599990874617070200855675138101007571137431140277671028488934687955509291116755086911502467217693065567594120098366890172546644798558066967708728506055771503967360480822306976992676586130056933183604260617366191616505329366358448827342202655324699025683788303752675645260484038093883057364713764502246951883909083072626869681242267215772490611190124027309369642911246133462435596030565938755104915408317469707052284802115796381673853810599811443112964783168652849311991405873959779813078024363134777828623037973280877808188115131595432968823044791244713281926328458658224346655275227486450398886637864723764744893178293805750220856919004285548583018229154586380189325662786312907429770819483463150156997051777645774230280349058738901484873562469682578734148814815893893147003545418044700583851489968989438756359366962465947152848086826055861895878129490297289265026240205775639649306973020953149495651408421644634090427529866907795389264811520138438183395447020457132585162467118701612557958572432219899067420712007606456639805277075541229852505100988771579758651379831508380661427144044026998783242874953352761645891413634534785332140635530178499696207124934303797241141628195378537957859426947210550292972435069145916887537239502982178012587029825834730034731067407007450594920042685232424352873104291060590894877762928502681347858843035189885071627310340744298338309755631610486907700018702919985939397147549961012561933240320226484505282491460365278420197168176316553226817835938489475566865430798257472618417498791161682994507566904182229416893876636070961261752394141257072530462607021453382753301560804762500964833889864254883905700160677728388707508796672753975594236441382761324664614053679071692492077138659170508793797487707949762474765056287936384028406253158660438643340493572253817636616239629751957348481908370128315690397578333551403691630434321525174777725180877745274577063053583726800111164081425123645674606511619861376349008898529598954902233968654875789254985660728761981238635649570657230258939110741410593255182296687456020001395991931581139489082603029401293438936485137878212764025270584340014106908324540525818068380867005796869827641209343664844237822224474895587081496618644466871306689547407458326814850007568237427696546896137080156855350550721647067599973876582054982058714654496604310087989144493337299677151841679851419603670890175457105932913121314650043234250120615283099045401941241525901033159858076408716805652195493982275944160625764085270539808023077633936347944265538553925240533238330826075905338893692992081861268182471797809552892353916011299112954030650228678189316139588772369773042620302209538588920131304319306652435371890963627565155474909120318974398897350127461365522129987561629841366895820576001976172595432781104023152211431879072693614669684832367880475505849942890912447671227338107944603938244521176926853518666993807560450764879557679792762153551642198035524324341999562995663485815395162642233261543879592267877423585805427040553768080979682120587391513351350405786410577293133215606586649059384373198956464671796602196687796584528888600643445909000499920614456606499557164328179811396852144290608651905493455527201979462574342065674389884055088959525411430743145501226914308817817759264375628797426216105530994953090254524249816288970698415202391316132062518467964361711520844623028857166736743692276133453378050963048308324538938333706860255883271276485801814871522491420133241727530870636207348154285969313699001294150583971351836702325081289110631625596119367397846156655594310661517394873029281956950497014605722521174794933962251907606207215339766931771685905858812601048579960304734980429678140460042487037359864429805027027803305826415470155885658065612241768103005682132694357885884592030854008481473292052333760338123327615534693104721287676428134721744467268599294429305621259230760272748691629122556988767058643256486786811899407590736156590750721437089826889572150271991960483422658835832791792492138425633772834709575473876135728135831911913441312210674697905453575439384767672382346163285417087279163797734749905879613172671891154176144732948207018025690553556496291702646126203993019044527747894530116476653041820897984832332372257562708711195019923884905516214960580400492574965374631588071972911202559860595828146375202770983199188261281838484051667623510072382149598459975894073292633296443611768188618150921288161021024504846240576366523449852652897376316595297531230895061839913821661525198618977306595158362045026755879204613956737194473228065350112021842763968808048715717393356562421913376244126406716878475371108505151728796404702227400896258984812173653731690246001212918924072725194929420592069540314727499406102374821573733861582865036167128290769623623600045011018417407978205461450899948732718931145895168073416642205128900873565371656541308427174758231157582858565584855007790488858850183638748636270850509575688947148099286225211400701741567433368125391314322356911086683313738346165426961615186222808995339475582278979064832048841364867676175218330697186774864896313542386271038767192692258741061792959115568966330938208447567523723130067764524878533137009491844046663730506602040019564733397807333039588416996516719571853067806877363969432261591931730523252724366035759671669062611294325004920573939171527749135566959666169462482617062233220585208226546239221952975633119887237216508240163457541183903279802827410527224486910395821172292019544103155952891397033103580931163369308432148699728438324650927711457058307355056258683280153935646326331432653630474707821269839101114770195391362047855578555783981065561811463580957557108424478817261619908443809684018182971602600030189754953037197032554894646686803056473157959615936271501614326856133152521483744881262944315378727139250763549407374759781943188898403527132952346819810734080983204115285838388130431772295582909801627065252651993646641315393863385915834886072593802811274033256937959822428778948847978763103153264378103489195395154565786928328263172082804906187630803520835695139008193282979505815857232258669589915663598061073855126269288385574578112302659911811942885210703392600480053053761440158595882213821753849469813415177152546922018818920942586227481625579319776072540015000357318450542643072770846694675602365388587739742360221012112670467804796504760182598014123505476784815965270565212566850356884598575135011259892038076767462816232960491044905503356830166756102727069445841618232262554001769950884750670263485307479255352975708668729207226366489120525642231402032391326668729273046884873577836876332544364283135790130928222170750507343244936873998313243288191629627772329946007792441294415605090112950849763290815093957281867619469253126580930444627167180541225817109183851313119162409822242635955306743749694060093013560543976378982035308703160264261984136726353507452925896008138852495304009406730767671091680038413459479040580409168809817535680453954739133902604889258682212005668925784567569456967885332730099182069128594103194343450012785517447339960801964922794207319677277856909464587594920349622149678705596410021428132021297065399298530577928345717695666761013473604884284907599047674885836453885652583072308480835458583809589981084162479399290508418983372560050514058719662301278068918279737608174189623308326115203894454489950666310885970576617549698816689789909503794814105573519471085032498595738679181095747727147449789487279683121995332296463375875018556178814463594074244642144429192944426457770878540899136633017150668872925907591106914208027005231313713390506426960606651031667575315581934006320771540772142747594541741071534260342344891597743225552298578878445573094775554862094706552845147850319972810737412491509997830382603357390341238916549871668912070134447045889050364386546081314962964923015485407645454331110987932682487175470725667553641699737521859072517055520468914755026433485870626521461636990510871780381807553606852232389468975138683694126185840993286605949391489631644617825828727876171070264955492111211274786468440166912670471508003897715557832733164434292256318482770681617315918680155366055927453215053528232483424274301162382833292065691477699637866599588363844089490772927582575438004035360302007347405686130501983888939434097048494836537214146129464172410431908058680055030839652306454307444339821181810092731305460760616922783760108575475666839837107865220254309956846091927484497665961744937356919750905712797370842993681174966214077366283264006161458119041099797150002387602770197566267831090208520551814578960938972187506176103779567520239534310398185031954209178645984331904853371376533889621548519187491294189897431405213893435587435878428138085721753968591636519602035494287714127603386553234625888082095482964424572322596040853229116859425805885131231216327862136020751610704677295073805304752140246643425519750351467390444908238801528027104975821563843833588194252902625531078632950546546064971628237834944234692804750153038485073128281447256700674321228813751837193626397278958949251993340390391861721397929796140876169444596125948388968377399790956573495806000298979845868417545329070950999889154360910518561300577570069463071378857476873975588444629331802634177700256220348689366318463000739673349548861884168840929387226915168674639047918777131888001746162335644724598319086232884338077714215476528586139356896069350933747662546842798256333228439483030281013776964632448838236940916074763864296489179061666545052082973066294032528284642743645352579121919411660978648369390863806417833132601024288572579918074332462467587166049589331877398268097934427751311492920769752076765829628946434905857472011388897338006815320740233107173965366969517910843090176597591752209138790674915416347718960132590945412413000307499734255065079752461486689736180758727659123436238658590971616384551457272125988542338318077885750227520439211258655379478294103532513820231122916233026269867269257660528003382506591178281336883938397752349863389153375427407648931279260085530928190165869231996261934790366398135814215775883227591561436982204944854257246072370071013076809564448812054813001061204816173003624289425091425731728663439519239731792781211400603586228578291938812182622162768709336389875801972747515108576910833429678199145073190753570492862005778999482060408005393779375359300169986977950236310611479900981465422329180054249998109723372982645463520408681343379941392606011456766961164359143500741965477831369033598123796361005301453546207510307304862746575818890600302618666359420143884552792532962261944919927371464084046950912764778048454041131511700898822019324337478982174256185200573701912403409885040812813659945802559196362329707210035093444570902026677327550769797883947565613455896160095954082653684355616036015220924613275920642383321751380617729263384009500769556041503338062397022305668403009330102017428680924677418801472183609597098072204883496017197617894573562847284836719273306626151572662911397081693473647444140871791407914476628525574112654340728755314992944712228450939815804230416009829518481795532491083903762340384544668099581143519550226038364067654044342212534325791503929019653589259406695695098825579504652986359207949614010136266604379109954440418126212956047221136061218651603133323247132258436449742624821289332778300799347418959202694997357603692471135981119107881641066074088643334765769783794584516420015732449824082934442631966586017696731999876552435277999649764678113524788686029775021274821255861174783179217556168704480969463789328047606646594184464807382714570961585540558242165930057250075400312868033272792607062111448899004676373440561817936909565993102313725768065255241978253810727757418662789171161558436245775569548188851958318311973285798194164055503898617540264557747068155803672393684530148342379064184949603266001531542224696823822042757203129182675879563388752452722462371141195951632659415756729562734485574392547572434320584495411034206811127445381445424681576529748828630198085322578852422522596302225796213699814963204086539266867769816924870897327186700940460297824655668187570857482225533381166134383938497053241592631742873844646200987995952291879848355886246363927287188741080252263647330757638664220804303618229797270654396116677483440495606545074135067561283637148686176028876792345861528797516002647222622275048230181568811953335842107885803783601924359114177358952229588841809344376892266781512467378499887347323278444952854832191941828092081370965727821868486642322987195126963479192900605714180686836247678166443209741790285623047119997268246074237108601254726534446067616982759590615067804271720072966140236613581544376478501702902975359794138337385491958778481942812238200878023833904175087415407176549976288645701231028561516846014272690430581797931689639878363350135742170534511566306090220618936852402716358826511361812466637885278370597460420376427601170239672032842138622030386396001748406245199015650060571315665998048377346203764454103848385420850707434208773421227427727951073923364239814495090740875523910943897799884067782891212229433955704915653461928151759305307672106108315829022926780945476759421463523205732796671136201641558191085558735545857531694833655385058057639648802943185418770392346363281218575732776760600164008649732325959246817836200420069591030781190653447375231932427686045982231274088620428511765562820315990313124480700232978984019910225934112770834392272422203581586859056892515135541886366057718015991062740348545976913130504936275199911909297665371742386024487822690801781763368446060853849756303095013319905529247189656295046626400731393521305604858683860212218237289816710168550002782470282822656934536849671505336838629734898552771872003073371539923985895595881269466277971812925123442136097550925140548058890385258455007764861377077097956096289553602194598701856511603579704046866325516976421879312716259056771846076029811733777273245268691847415190311422124424080863344420423501410593995161820723716310654535915372811377078546000603741874862728479358818336680499396613873126944597507952965984674139951521480961155413545032381464494202297254115964488619315106686630676629700711765541931261368470375525755032282804579173170378926797724024757063005873610841019429176648912908498912598783489285006103476761157355425594173893848588334412011375638312313516763618938719128049452865798456491440372221998214273247542363477035789892943557121319737646392028953941355554697496946935594547666052910187898996394485513647004386273519934546957730424278323654929669388782513792874356307219152080461740564799625094211118157041442700810119773959659471301107133212768700373469503199440678925009168620880342585105532054602685231561733503864337738938898307052582293040617882356553139783816223418224844352525211151364303519303871546840969003678337561259881130878369849256719736209400527331372973448158910005636998299828511729463932708441321532474139072826162824557283810305876349199670322262650447184536531823579257096301843228594961409093302777136677260071778639809834563623461955195703591090046282225145868226767481164907823411870229751730251520184716397872538161410601318469575883971673537460156158308558735575397273492471442944985216267872214464048472525873692732052125266282556876671021462210447162155011204385986185048410134851278790866210299366232074662823269711639112186765771594454554735797139690327205484781287784059011251448488079369336171800175289715749525218942010611953457887702677288339724396716330406716941056339384343375053337118774052534826986650122580493448643218317776015364596793305403327631377155811255131964769421301664966008178321974658905324851238526838946420912670024613272753835467856588348137916634610010638446437302570359870971020769385850964662127448227356789601462586632629323275673944877492167890358678918539309473340701761694863915003083764730169906561855227475882313794696689973220529352498289114697410738908425425020056903946467577225901866864617605146983852186333338502661166147257447128806654551650640510096964884694450904627243835914565069023430229329340147290414047562463943648642717668171737562986079588355875427516974964298589277849816558498559207714749401039361101267147365361832425851676058847000440635208434839435444098813677903183917445495793546800179642239551561065236168283816580286389839210580086711010346253251249619455881302128682143003444950300793038268780094865946224228714913731873715793900852196609349200854827486998102987535820181306071931962767926778157855149305091546462976156399131208976696229559544190209776664905644848268282689067741569104517898179767265577852944819922563739565104479771935808392420331999721451145852527024536886896118044439068962612022086906618453379207616690404440367438009513395140903065442560787879538784438536316400262466810567000631751734542161622064547113434716109086785292755382463353786673268492059623304804336218449951805932724235297971136874557501402303956829969778237594694330904143845593682911556077811459305945339748786665753558002539311632008877507139041023117830296162863898652622716902564720791913860156997537652871178149705033296436528743815479938065040160845765226922611718908944260558836070471457989769868385553396634856289683372831210363300600568344933999056473215384022799561473237396436620759000663000039002549788062524864554231141660990393210178837132696442353540364729367328129723489478188788484586379834756929581942414365154692133766025978368626969598448648629911747675138842278528119181065031660003663724859603249401326972753720843775610860911630529984947649433621039372127012207629830846738597244295835897973784798855562194486645842703800446421083302813236460629516997023124190758361166524034358243140326783846195526137952026095166220888594701032786591771777646885187276650107818739225143989289380299121216145598912475105187807148223070733767548165048823341307296917494527179083958535299257434212449989838224245658722771615626709752356236547233114986159648218338277595677048413682824851200811400350501717657966456269387876783449733631958454073197377807569630052584153027800869928707597740445197520778907777833997767749450124821959913629822605794722798044595463904679168556629356503033723348908330936789175358080332940163529699631970765498098506767829329318798776390512115878437590435702945037024668593906895397495842028766952277757463213538975851474764585830716285980708243273876271232624220841783390594062322010375067945634857245430989531438804691596904243094120417038424735644428157171710480116171013253064134194679839387360600302814270800288789704833934039258781431336601151258224419417720836921459378822972857368080567836642406668958626768900835423077983523279046311517233121861472513108000224927075155318209679953405045037788792816716409957248584744650536451676811443485888729658570818062621043143753129761687365899600141933448804612442539986265629453911910172439596404676588451683833184499804237448915426861457786087724286106448242807887968772569907900026871032951265111101169305721733790058511914294448121025242434799741698134775930779206640772127707813944393570222857080105063827630278964709590355585046356275948818287583411234082274241598053583901306803540597735404120905797099987769845678122750962798563071612963877802507538676574262244457113154874204663467446952100940537717349387480109562335741655843597551592359160877627376392650702009647546940327192722415830346882357534210313829304450338512258140767205031658338320896404903781883347621397636598149127659667605406923335440133469651127162300278502461908791603013896748456806533637931148835191606859729880571723385900748694428624924802820112188710662138582937777143066023718896085888789508329844829724496046016354117141952476198959700009433120488539325878759615621832042501284566408283966322621614018135183406962929929020091951503046605400608296700591104789647166420433591944118793851554336647155198076329072924619993019915677507902066594177448364885638335029629567664951678127119074885449121589015055987900174858692782338018176724754686145817282760043804339597651126470129973617513362613555861736279865855101956130094707868128884723549929157420859423337249635177731835011506222999556917130604511853951085077620477311131094044189024735225321996312054918400866452976598412960333598581280757587499924354713627790586693743365241718624675026633271798205404487932010087514913328911738306270543466844116840908515849795671346744978832708921356553386673746339153458834918228681290904808048964006273378048731384015770567847149281687037898653991164126205497356545044969824684174702168901978511468617183777335133797162232559957792289684962855376437940881968187239853911417177560862341191917196719347998353816753779852732215771427722961036101959279947596475762391446772217424052374557821819773891222650135004380880959284538148599946501698040082796209234142282228136639994546503435314653786552171697411910177527260387476854770419333570447253999730502904091020886753526594275833906541671964952816807439055405611242567246402220875932523653185675665457085870224523570299892809148186221158420248003547343712505319747547912343127160353662693564632322601386076541597512272702659289126029784718481689041690804716774795776159553238068751241313479631587919903007938453829712571066661989755018723972521404010190554490097408858569819921149472653103626640226909918995180277893547707216316476181334273507359870812640458809089609165613063692029467946227855953381813330321507705967419584481449994560900398602952773004032680287426700475365596364988367687180336043601268786109640780716178853975519351743654630357868687106817331297616244079040276458090706785905131934527867088484408206956843536833630487288414027444695631195000138932295049867441109446306955557879349604423675678688380422230472654012650076775688201275997494217956515748230961651041146815152629841633891302858374737556122329814661146506845190432533774585795671922163240402804721129174109565201376739816791547815307972717098655253744943909890828608613260304489271280014132913602066931592583468250173349218862787548111828696353092025254123069831467976001574988389736320054492567514222016115477035973432261859302687575445974586138078033331103955668557643840394012099809028010698886053006403640310268025898110093468979198650803329855174305964408424895556822683518934521294090570228615014705341962916316470849774647217595360878015080958149321213503058946126313234049799118088559767693291796433828536774823768341544389670956335180559597478617264148942794778250582786017202896899576626792406868516031133403366356235057659596936746969971824643671379010640081729189730125957046574448437649349896092711795525885257978869616787023518320620321711070073593240194457618035912763563987546882654445096643553942509051352713308827387291288541347470756487718083418449763444780116343721848422030306507425074397817121972268473062563109973913283792852472444145720040882177040384894669997556569241501869471627067286197250449757080238047594188331273809395546130839093281121669874133352170683819589260089337335615599177501834305515816259299665350465055692361908987459791484547701757408397894726263517158709187191454908566856525868496092394639646753449413177707219597741746842630314946657049899416184938786836598990185125559915216527505221660120090461166663797693349331192956274888671354434247491517873084179223277963566274220320364082181977265614230407441880397355336271334737245056207681428651441009625108977423706473503121069978344222925013807631055991797838051208562541380151104618175699227659183714827034409577868835859452986220636701929555373485512586189449123879975286647570016519274589745376172586911158620777887675077521753221856054223035866047554034796156884492098122884473084232870374093636773971877154614352431220610478098658802450851849155403180594752791026180872484853662986575926707588611335101164665688594753463259280084260534030677145625187530614283822254859918648899248210078636122075554432599188824040346443587239366426593360727642941213116964514666087628868904976695965234030008118649327589793714719599527575802667232679687586730057263714722030903503585766495914415474756639144596546733895236259494478883214901756738960384626257735395883539189646683292350746563374304408291409090282763825562401262003904503958995957259319727643099804101089073653473931632989113344973226450377613318583588922019221105561310877712590441924691126223067075776079445593596173454720796359754027737650964789410115943500430332858810760236288486360309664837895615079996878422088427851919490539008978230316604073904229050100808156835483432031433172920311196379696591390744530169603228582135704272387325004143734192140037077863240715151582956557515442215628386118509398896831150422440357295453539415007899901855055690016506395311133680263289959700796017387692240550352246641952288110799855705110889240227295606135098244231506050313027047127425956924288678506048795702378684759027670000704326091944941331422326055262003882549726196309813780940104759533322456682916425030218049531582289044958463866813170571929008498504732125713119300910117642097066439809013598476339725715113294243734476963998859547102978608039714885289540167194538523231185312394146866173185999496302766069490380716835776937073285783093326483024238018620972575886260876071065021747785914129931998038313142785740473684003814339338038228084235320087054233439876908252013006463663998359324705076216527269245564780211858149064117189472803964451187581504225602920126750333049032570770406206448063866202385169262039739340083688520725998515700580820804079031221035922530108750045716798005701996434213232397620963564574762289527077919202578863563082041377432789804764818010340812557371142654139608250318987809983939953927872677212227485103353163770081533565008616325186579074712621584546555104969504573943041541528124194046275552014093283947634749761597343574246651121142842637154476390224635686008012358502124722950919857222966219135013141373803984495727449417095959529163744495259458895144488881690181857653047923609934999364593098686615603099760450390330725942854207537776864326298697052832783528635064072324359035558035198390333359175993409177927423743389098213571637671724239133992161942646670876629307579787390011382725584260063648735606220570766347214701255342865433947664213315829309448307935006200791789866879704169154200713372349279400534495463698091311421321473395874398868543912072913645405162156502346463903063964293337714538935195421966781514000971849741525504825841350000001592034427085425304811374066477724730875772748523515973141163946858282332037136788205699217183371339469342710283021365290868674840397656343905043673512168249475782652887581465354453944908314694772122983025475152437706802051496549060032233091528764850554129069991345415963012261379643059667487306689175344432279002184597809878513566572799348664274566048727794292474971723660220265999848229303333965115482294270020254349205248982975678143600988957942416466328848489150656488919841015643613263175599436676138775605514928468689724089309003188800728867250958435599639906155194539735129256401434718735672836238505612882253526558030370177624906207895771332451973679498074403363775272718785553900610122814125307688054557310780792309106016277147166574557547191463954114856710304116801532425719732486095706872358745516336312511916392899541949660117079089375457981915147281780575665165482363645703511950946150957358861163557522609794263292800679447138070841670964696206134016528159305255913084278756351380155194989370033013471406480033390459915193541641300890762626698748446814820731370013053326947541305394331068959128142789082433415226829102252191066714729769871033644380454205584412312762118064369779239262855675486047438087148315702834026158064124542362817171142026811881854387044595730061233320850135399947239537030395293785282491807382572374447095906302500798935135510492464996952128016652198342970309917029508159771963813663101769194363697841474593125525671698996077179410091454987703006958484072563907276858662390308279956042034787506072587356053086890147043804444387211406758797114311387183514465089930942657564260417153816572350296935348805268210480018634867558775146911113252075943666503881886990117051993697947772807115854617715743748673555705983790717186579735807250605040948091836523089240081369530587294839021340177631766912073408628719433916319148098592494952992159993207128944507862628697505822258151137293189768076887596005770360183389186160493347318527474281107267324131221440649581222553015637351133575397150649192979236814309895117040712870905688226676592211272329692200342335592976823224781106553033604177664342791012887587181598493798219093066803470239708596805224099231444184716116648709226387450364523222737024642394828959057101118959110818499728827911089041820448306125542063653354198563704072080638279556154906908823429949441331070059635531027165293618644545527616094765434088810038611897255912780192507688091337882657922971629374919964647673472145104620912037355925086832357464126053576649546429597530506024413885993762684307964129712876243155501211480734356087909770624637567116470279136307179198655266086183405346867483926062439916480905826290635406949446276747019273489959172965077279924248859799222524671419264727394504405109745405848797178817070138583083582737994849933863933420530475722768131158137143373247597672214127617592630895941606528562925913512754083153835216068306502879320993073903494410692261145611180230232639487366426639862308839696671114829849037219118629647599852000791738224803852515838596734848616175520522102467981416543880017535544194578361461112563592251740799779032384879512567708955313690298331202295285708693405001260232362899927315324675001876465249434749804745017476354708839470781868565175297741939344462352146888465988515174540026851597801136105033652771360484322708211780161493022130898289829841451496486244508828911802874065842497422429322496989706336994603571534537515543977032873964871504563779074977996700009976832479638460892911642194040996437710660971852185654270634402225636874884238130995583861961794109906248565976374838098598004865446740390858686281326928470819923614805966280262858839275038062612138414801793114095833028575629273602757483767788105568265043648130308510941396200790882501519798702612841590827154207703001329408450477372314193283189647841667139113818513937755298603016360558192898943570908932650277338334434128154523044738132272287011485329335360920704109160226979473203929279619819935697595050596160821878040782002974043902095383379535650230474467622330457205659920804162899627469947542194704961264095836321826955624509822081151628865484286035191268943897683929418646406533731661509187680420113671515857470372919860022933537539929892413561264833786222072611146306329692850503436559718141958973433119188221920159107417434825289170670184832212350015617541418739541731033081020470913240665951336061861711233326809593216837828759817840375655684034298153776494562809144771221416447674400444703938688987957513084846937366138213237524442909313952198985141523969516278499580077277022366451087338727019743941140899350320181893370865796606656115616939172931428763301079933923389531536402291694974399575835116836606297521184136915849775478874478780789562732411176294652077154725270922345955478841297286197064840306808036855448789569489776974452123861726825185982052970252685682099206388904405261337848925017121203720417103472671169609587943303696979785894432648444073065213659302102834585455740099240068358008561065685307747333498352185718027942660007033120826891986371300734046285197731909728682237406405162438643349046578640173722361946125894321105308598791155950254585348743015282161347255348423371459145736857267007184735722567920715365860138028277141570663574346498265614378686188865331834770411987300943986272531572349528119533142589394807402915488124688289189965507350005194624043380636464430052484306025498872880918182288112821813209399942404834262815175213924252891167778281704700210317296811317056995854163774526822168671278882341617801915125242193669110788315074717306426410185922530773669908300348121163618305542541017472370747806152584325088529308467512464307456037217507746113111097065331231829837212962797616223449480424223907474795233298644416151779053957916893290125383848402462255807825940137156563742953672787041291152947858439882939548096742164110134078040455502614967015237713047374088712956318566152863150552807492487340829911446688950138413427910560051846807221266470530859527127163566147468711666242170949808570012804298721081527312250970187035198350892397110813765491304683056100623250209324296740759417013505575423169594586968966157126233513917684681880976588808096372092140099893969219318374442616516794627651794471877372890613775049107777326782706568994664612979452835817247527328623616340860276077651043029921925865632337386719827463374817958717795505872545780735161829267366170472854342803532047182466391905440850075252693994401743628447697078122247419386591646377106686844330943944037661513640811940255348977921553574368977328395444691293624360859491435049152801025992293786044040937213204862904260543199361002722599038982519236164515516721894496849444404882480083836033216868278754065144306594130860694391781068791587058187839748061302348644278340928461847294828280029882051559939918744985151506065661293488594343748091343775240354559488795251118218999509514313423979312960207252560515115176867581456062071671012843691281455877570634342346305501313861916489028761256677282828249701038613340683442297121346776362005005781322435926700107158263156091731688985443141222551104498671252849322060224795567306174150862579748314379594071062198095637249890576710562659448671856429278294121072433372673089671503971635604925106517426926920418880298185125035564529075780716803766076427484712386571634934066715125050431374677856757298696524064949002236272688438506697242747893035459139342890577545068158753340478738864411900732649359890548797594118771154403611866497665605555482527960979540256213895516071800342252221850021716844566340691534162343475019296201306369052561305591984245672014882888376092096245141025719969928237619372536913401202009932374349189774659441031546145676654649560324579587099107858335816639231725400116159407358515621107067307801826087158979333024195541329993104804424465267175337468116426886242180197930430022371881828328880178456228805605624321527646608506817116087087608050404198090698637813937916428730804122741573592788771481797550621957520444319557136607145747481318573092742581242944287528464624259985642835954228121177192988185637500570188232510587243861096391467951950938081201943962668257588788236331764473325665142617543529663885011663394979620506059953501296389465716100468495071918247061580418074164949740367449285814520111605367120306652946984477407189187490534063421065026435545788186468238648112585194871858014582748912460060094440168065397866922457441513671427249166170512091104964730867645289076061158790262280224119249152827810433591060775391884585692599107617943907278575332594330187179988432044017980243464156097569194703863562988685343552120285484372492981041875899533527803354938729272747017237189871899207384020006317613848845831405191669721194655591336476789128005379010367018056696401741148141036142024935274951934089318302375521467178056425813620041323668236639239762226481145953466468169459712506532836949697323705372485746564307955997350195661520223539689843270369143758629724897090815743187698669344714794900197390011449547058588770011927533678346564029234561927395528447079415728319096421916125855521991948610962109340957953290808305735708822493498363260910974959374881614423105188501452011571533532608683810788277679591694750262665062985106998708624849200685124132860952942568882955969297876223682778386248435814289614334967253266394222562020297849830904749329392514950770765072710216167478772341671623403611025558662584601496752561696691849766302590196174252734877173577984195319491263037857849161610162760352905120416976828972746631272964631129454520019418904383518857563319516655259207433935453335975322543024138702738602803909201751456438041838095445689639925664649692715844794835428430140636968593189764715742286843592730762592754049065185015651589505153523097349518292469772227284839822911511754361690461057436057583454575664864822188233383485429300150196335811253386821991717901942584208793156108553577070249172590029603772750647527914090417829718671386446003469172153404215217497113130432866492344881265925148559256813229667211842031927370545549714660174912741798272043671601792774607888447229044069944829444246825626537128163918729769492580978863371621971803911669672841610299766411110895457092489873970214271490177605876893160201597717735510943677865626119790697046442222536876610206045201408796146836102544600564125781962392936214499338459359559152131365015432882338841009479527205523987177304717072281559653332473935977433231353189112138013659384831452140385956860521516727589032517246946034791026148322828321658514068867300876999483708561320022076984868926917574388811451050368787807365262922574555436892084157749603903191044965614816395012356870446851266320803799209652958808631413802887316277274893704264125984867497938150965485130838406468181116584348030587923569929177315275819006297784695658642688470344213758441551196261816838791648000151813215247298697587977788718185055236300230660929253839105454672485214427004659782666029390656463281478181097910634192377401770322576732493215868357583695294506813459272427919179244969153006858105546626994952994118512047866545600603720129535789583806893424229359461506966179435777684139551941285748492503838690406576231065942326232323388698156740362812679469454746753871485346804081886663332329629310883025811697122390019262395667393323418865792974069454115736816570341438172416065024554067697706844158034130732682598811936975321622131381727198320435696428509608884836607440042006676048179534855815898886140278846510987372433811459876887312244758340090019964351146646616658091189354177963593471486435883462900717296050603095209609121689827821294657418020414739199744871025814439999592834098722725252085868097234279356163678142850063541814227162282755146350693556938925330412296392608017244822509107510620887730842428101198857191806211371188331945564716908167644418681474340837707765351287903960306861965481213087366750076635371392459871010857265698918627860281073093054835555780359165771415415117507399267685145105771033718771239247757807917216798912961693399062719749713879302294670843542696406210167624164612701928416662979939300719642112005084156134071130717266560533670081171474315638608301931405904072051971739484041761355099268045577733779987310573044093686756955348686282814580425831015737639168840296309238097828008568808773578402534544646865452991033412501025938195471274977071388295293416285313903508023496340500193328492837989184855581660984204168751129062967798762709213952222957082368220707705459831288892010690911730568309354999021416297384441955947094052200672742591572703767122688974872724593260912062553007721243726186361807789843393107921137445763069508401328337410367717244861406209940359719740958448087381996353394193480025877799137098361510635542680922461564672409812016048473221735471617696983339173595316611411375395565344292858152816377388751930897564896438084131816006542501295146921453755396001056693891973895236365621757892131675030074949020728626366226970634053265102441192403436865482861443384703411366823095196363882301332057142882156283987519668520399256990572380282410802726145851791685766747879434862779407474063269557512688078043994058489690584266443550619454784305442242011153429453940061474583365943228366707960540181772238160302379258496973826814721738874228581962658686445766387203456593246110852807553255299343067769916112022869190088597784834689896839445556927589984437429012115055742543437190161821656315128546500993027320015873753186566045905001772996581830686969439788436105993130083067095132074423339521529387351820823945342491610585851604521648062257944799223278609446412386830852487239602110058828206456016196736471418539598248248725002521839357904527542437907445923844605650211341196777326692193569413486865136020046450163279295961582873605923894775733070871931146128238218400367164701899840042589803382808052141872439623975679571822083554434843746949417956257853722734061369350160827853269072719129538302125673231321594347396014146236207502696954751061865859821735721353840926886333098007009777551457896460093375406891665394573897857939221671173772666198043239631806218058565344554774991313353732831569389036043611724975912407596281564075515612246144419874698332685962160007697353147606297090619296078763058809214271622095032339999261887583667187452480539487371068742456212957712638822062745546809033849063904736014958088058889085481780659272985270700110936650030234022911945207951183040939855010391819488530303847655160818118605089028809996000563204483492094613523565466385929747117110485701599923669720045180840494492836866270635488053853327889196886046269916840669476190635797174400080945731333001698521336145940724829849828296016392508100384913468448320594221128099259987334118132492804796300804047037889859327726909400309036748054977396652414175814908194396863059306540681103998025349049930030805184720790029468836571142836829326544355314180465081186417660260898212461283730454276791768722013490341607033773288538899411994222566894329392583649659933595870314953495848433543008989346809963878558157698426203147032269879171691672102370668130214258204446328619991878990832050051960045940166629526684088371353802983927895861161793298669189110778040751701982824796864565322902636958323455791498885665073884185620757415057794662517579922320013690141588732188216763439499030184402951971620816882770900141922098712053428153076083122784949266931201302108980597634901486766731322569443858295332813632794468117935918349107307311164902074015602674065061564124605013870281638587135926474145251928329929631520215356339768198580755932281923588246167902437521966071105424837509218960839627916384931721063727576131156266526711199385195082954405404674693308775391117485546506232849968863272659798304315269019942866949349642477667458071333209127530241091685388024628310336161477227832376101831920575694202746128500298302567503573051399711866521545285446617627443655198261384201987345641286531651356087216931994710460737968447733559625130026136708005444292286090556176520448336787929683570143989000945502102723408740715316427672240354554913894420276954219198595194305202881154252757230667359554420843276070686289424438388186919553200859774911275306673828734302553506267901381698448303097689793101951544395259369484597439133901353203455320140847125337484951346662263448170407377261906597277384902594295756919894960458979047439219104601284438233743652371227641320760799143635841138156663987984548636442097818781175499211815846455063808479885492342440248149302214659088891015477303424581142388133882066840946593129099154139064144069560876790275060890238157269979442345720867603064806238697269912295878913346857066598003623509259834860748861297924697488943575118109107180275365929692107174674209129313061797315042377960450437811884148774833904408008405971841024455085896820097000918249733754291449155962968949828021720624417946082946373805352705663684007216940082092490734442031850530394573565070033812184668832931114251952448132832056454083869604890832988921788129492517215070569378311929742251310118182611999875825563475358563584621499916954930033838454954982360714410988152819130983664684003861700530774466942306927990245460244432590490708185986150774572253808925233145255866696042983171373846321780576849798057297720804109121888650111155953054006995213199582085259648612376450949811191573743701177714886622101445539402835899565521827253033017976214422690895253041179341156349232867536018969151754212930784594205628445991543304529392702308077253199525492568377437643649627066633557784835614501501518088093187826592939631490630897357612910797312539195909351468484588713221748514531684908948434340594277520959918543120005772459273553003496378255248862128562858005862833649683754192865723564710523296820853408960678225371001098869546222554921365783037916648325160042388678243132714804777476118262313975544586103652427451610999561841501081311638747209969603761727749382246441523226299941490181317055356723374259902235638849432890007396920024949591775926585039423380979095855268022571780575682420381239219714783870374504228832491907400268771218071861214020443631665879994140813162347740818595166532757835095760721705989368409864335333459008443094735203522217922130455352295676908059030193768005065655868276190789560261285107808282712364920061731139238359270115538024954437984349110674966488610400509524566269818902579325072615107486449355151785288854383955812031608661831579518093702651017831107707709132996231500342513082954049441284033514228874941441923193360100773063293944357565306589882641136793476360020086779037731336508049575882816235609390801688741315459378612447644610206222693384314377129003724525078315265049910879899658472164419913424489774297799396785246252194763277880981523950688538195808836123376001902555264712179091543670372498615190439058245696091427804215521655689652704652312579196108171914526390694433178780548847887106395674648550007054285269313115661337131347520777031142588388334233628574126627771153998191649994620394782805826571416621172599003923665507261000622018083836672094439893060715883326240489267208481299765369796067217598292828047602307860438546725590968579713125740715619304628623756305195426325666814636804137468928047480715966154163777745987752815708196890386549264930442969867890561558965760674033552216316194699339993810742728227176639160608755545425466718514825380197057543139910841115699800522530617867932766341464440605367186118979461634987559766477097150693854266212627274174700679573005459136343142637482740441927716139649724215011757775318923853900863240258196069250939177175857449446666182706118570237680583028537137481517554092977886892942905377514401164576924029090325116174608160895660348618777992969471846254169972139874635677398916747088679404341867447562533245284007953208356642357184969931661133821991185718568688141268124051850839389609309729812099995851429706797163974230712549642885866019715824631465866095160153594376902305813647769340417828523046006396184486955814266744515057616952307877672554260439975612008219627687559859632650946156250334278304755744566033488186206799453471044654755405639961042776498662138136952595764078490906821659367351118398907486369103927523563863917253060412358661100196851378678808410447155992161694769619341192670674475301279114862491638675454286562347262460143557842844303598427138064829651235376153353920298216569662997216237925961703307239265008905962326088580888738774160551585919820195331846412780369849175952900476453260045669304322606946631532944093247015305697110653138093403329803993857122417366893082149858685722233726214327163973982926845020257909599638834197449099967319504337379063459627777206587423423290952571197091692417867937989192596717567676202184024437611280274727568906571393066166442073305964287979578640416330681942874365873446376130625084803297366374869614343297219940157759442997269759306386486528774347578896721759840534357946161463158797543751361749793845697818989965622238236306669225031991258390988243805109332046039101056866211588502834376648499948963007901412076383446596918715635798945763829667966082343763596430028052323367950085225585570978693794341954637579048185676145793167880846302979568155452447609393165219184694556547568563049833746616099084178104706579783956643885189182687944337355411829160776115749158426216371198975733337236000622677975532062859889663984220245029614083499062056412119563695415969672881171577315074977121612997201641494418163124665189863336720090047080384520380024989801688508796247196538755854267152990400356333966457448513513783490093356751626757780404302378718179023586666350805807933966952201429976981679276486187406234131642651827515619233568745746525384050433560149042824676641735456001136242027792933334945829622487781427056361761844835076641985169632599306812063071543550215650354087431074151444189330477914230371357520786575009901912486722028463720021676369386704731297397149687396044449279815084721424308311965770758507105755433087416077040541251678966524883733630056691812581998235914062755215346902830701892895934337167958633033925506277564778413019449268398092637819117919226144175987747886367302787462644684084678362717935369253359416877885443271411157903461506741566545412586156404855949968935042796404405451243990144056514443020139022186704960181336090357132472405537467161045309505652674100300676167988881542412218718624389121"), result); @@ -124,59 +149,88 @@ public void decimalNumTest() { } private void init() { - List superPrecisionBarList = new ArrayList<>(); - List precisionBarList = new ArrayList<>(); - List precision32BarList = new ArrayList<>(); - List doubleBarList = new ArrayList<>(); - List lowPrecisionBarList = new ArrayList<>(); - Duration timePeriod = Duration.ofDays(1); + final Duration timePeriod = Duration.ofDays(1); ZonedDateTime endTime = ZonedDateTime.now(); - Bar bar; - double[] deltas = { 20.8, 30.1, -15.3, 10.2, -16.7, -9.8 }; + final double[] deltas = { 20.8, 30.1, -15.3, 10.2, -16.7, -9.8 }; Num superPrecisionNum = FIRST_SUPER_PRECISION_NUM; - for (int i = 0; i < NUMBARS; i++) { - bar = new BaseBar(Duration.ofDays(1), endTime, superPrecisionNum.toString(), superPrecisionNum.toString(), - superPrecisionNum.toString(), superPrecisionNum.toString(), "0", "0", "0", superPrecisionFunc); - superPrecisionBarList.add(bar); - bar = new BaseBar(Duration.ofDays(1), endTime, superPrecisionNum.toString(), superPrecisionNum.toString(), - superPrecisionNum.toString(), superPrecisionNum.toString(), "0", "0", "0", precisionFunc); - precisionBarList.add(bar); - bar = new BaseBar(Duration.ofDays(1), endTime, superPrecisionNum.toString(), superPrecisionNum.toString(), - superPrecisionNum.toString(), superPrecisionNum.toString(), "0", "0", "0", precision32Func); - precision32BarList.add(bar); - bar = new BaseBar(Duration.ofDays(1), endTime, superPrecisionNum.toString(), superPrecisionNum.toString(), - superPrecisionNum.toString(), superPrecisionNum.toString(), "0", "0", "0", doubleFunc); - doubleBarList.add(bar); - bar = new BaseBar(Duration.ofDays(1), endTime, superPrecisionNum.toString(), superPrecisionNum.toString(), - superPrecisionNum.toString(), superPrecisionNum.toString(), "0", "0", "0", lowPrecisionFunc); - lowPrecisionBarList.add(bar); - endTime = endTime.plus(timePeriod); - superPrecisionNum = superPrecisionNum.plus(DecimalNum.valueOf(deltas[i % 6])); - } - superPrecisionSeries = new BaseBarSeriesBuilder().withName("superPrecision") - .withNumTypeOf(superPrecisionFunc) - .withBars(superPrecisionBarList) + this.superPrecisionSeries = new BaseBarSeriesBuilder().withName("superPrecision") + .withNumFactory(this.superPrecisionFunc) .build(); - precisionSeries = new BaseBarSeriesBuilder().withName("precision") - .withNumTypeOf(precisionFunc) - .withBars(precisionBarList) + this.precisionSeries = new BaseBarSeriesBuilder().withName("precision") + .withNumFactory(this.precisionFunc) .build(); - precision32Series = new BaseBarSeriesBuilder().withName("precision32") - .withNumTypeOf(precision32Func) - .withBars(precision32BarList) + this.precision32Series = new BaseBarSeriesBuilder().withName("precision32") + .withNumFactory(this.precision32Func) .build(); - doubleSeries = new BaseBarSeriesBuilder().withName("double") - .withNumTypeOf(doubleFunc) - .withBars(doubleBarList) - .build(); - lowPrecisionSeries = new BaseBarSeriesBuilder().withName("lowPrecision") - .withNumTypeOf(lowPrecisionFunc) - .withBars(lowPrecisionBarList) + this.doubleSeries = new BaseBarSeriesBuilder().withName("double").withNumFactory(this.doubleFunc).build(); + this.lowPrecisionSeries = new BaseBarSeriesBuilder().withName("lowPrecision") + .withNumFactory(this.lowPrecisionFunc) .build(); + + for (int i = 0; i < NUMBARS; i++) { + this.superPrecisionSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(endTime) + .openPrice(superPrecisionNum.toString()) + .closePrice(superPrecisionNum.toString()) + .highPrice(superPrecisionNum.toString()) + .lowPrice(superPrecisionNum.toString()) + .volume("0") + .amount("0") + .trades("0") + .add(); + this.precisionSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(endTime) + .openPrice(superPrecisionNum.toString()) + .closePrice(superPrecisionNum.toString()) + .highPrice(superPrecisionNum.toString()) + .lowPrice(superPrecisionNum.toString()) + .amount("0") + .volume("0") + .trades("0") + .add(); + this.precision32Series.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(endTime) + .openPrice(superPrecisionNum.toString()) + .closePrice(superPrecisionNum.toString()) + .highPrice(superPrecisionNum.toString()) + .lowPrice(superPrecisionNum.toString()) + .amount("0") + .volume("0") + .trades("0") + .add(); + this.doubleSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(endTime) + .openPrice(superPrecisionNum.toString()) + .closePrice(superPrecisionNum.toString()) + .highPrice(superPrecisionNum.toString()) + .lowPrice(superPrecisionNum.toString()) + .amount("0") + .volume("0") + .trades("0") + .add(); + this.lowPrecisionSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) + .endTime(endTime) + .openPrice(superPrecisionNum.toString()) + .closePrice(superPrecisionNum.toString()) + .highPrice(superPrecisionNum.toString()) + .lowPrice(superPrecisionNum.toString()) + .amount("0") + .volume("0") + .trades("0") + .add(); + endTime = endTime.plus(timePeriod); + superPrecisionNum = superPrecisionNum.plus(DecimalNum.valueOf(deltas[i % 6])); + } + } public void test() { - Num num = superPrecisionFunc.apply(new BigDecimal(SUPER_PRECISION_STRING)); + final Num num = this.superPrecisionFunc.numOf(new BigDecimal(SUPER_PRECISION_STRING)); // get the max precision from the MathContext assertEquals(256, ((DecimalNum) num).getMathContext().getPrecision()); // get the auto precision from the delegate @@ -184,34 +238,34 @@ public void test() { assertEquals(120, ((BigDecimal) FIRST_SUPER_PRECISION_NUM.getDelegate()).precision()); assertEquals(120, (((DecimalNum) FIRST_SUPER_PRECISION_NUM).getMathContext().getPrecision())); - assertEquals(120, ((BigDecimal) superPrecisionSeries.getBar(0).getClosePrice().getDelegate()).precision()); - assertEquals(120, ((BigDecimal) precisionSeries.getBar(0).getClosePrice().getDelegate()).precision()); - assertEquals(17, (new BigDecimal(doubleSeries.getBar(0).getClosePrice().toString())).precision()); - assertEquals(3, (new BigDecimal(lowPrecisionSeries.getBar(0).getClosePrice().toString())).precision()); + assertEquals(120, ((BigDecimal) this.superPrecisionSeries.getBar(0).getClosePrice().getDelegate()).precision()); + assertEquals(120, ((BigDecimal) this.precisionSeries.getBar(0).getClosePrice().getDelegate()).precision()); + assertEquals(17, (new BigDecimal(this.doubleSeries.getBar(0).getClosePrice().toString())).precision()); + assertEquals(3, (new BigDecimal(this.lowPrecisionSeries.getBar(0).getClosePrice().toString())).precision()); assertNumEquals(DecimalNum.valueOf( "1.23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"), - superPrecisionSeries.getBar(0).getClosePrice()); + this.superPrecisionSeries.getBar(0).getClosePrice()); assertNumEquals(DecimalNum.valueOf( "1.23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"), - precisionSeries.getBar(0).getClosePrice()); + this.precisionSeries.getBar(0).getClosePrice()); assertNumEquals(DecimalNum.valueOf("1.2345678901234567890123456789012"), - precision32Series.getBar(0).getClosePrice()); + this.precision32Series.getBar(0).getClosePrice()); assertNumEquals(DecimalNum.valueOf("1.2345678901234567"), - DecimalNum.valueOf(doubleSeries.getBar(0).getClosePrice().toString())); - assertNumEquals(DecimalNum.valueOf("1.23"), lowPrecisionSeries.getBar(0).getClosePrice()); + DecimalNum.valueOf(this.doubleSeries.getBar(0).getClosePrice().toString())); + assertNumEquals(DecimalNum.valueOf("1.23"), this.lowPrecisionSeries.getBar(0).getClosePrice()); - Indicator superPrecisionClose = new ClosePriceIndicator(superPrecisionSeries); - Indicator precisionClose = new ClosePriceIndicator(precisionSeries); - Indicator precision32Close = new ClosePriceIndicator(precision32Series); - Indicator doubleClose = new ClosePriceIndicator(doubleSeries); - Indicator lowPrecisionClose = new ClosePriceIndicator(lowPrecisionSeries); + final Indicator superPrecisionClose = new ClosePriceIndicator(this.superPrecisionSeries); + final Indicator precisionClose = new ClosePriceIndicator(this.precisionSeries); + final Indicator precision32Close = new ClosePriceIndicator(this.precision32Series); + final Indicator doubleClose = new ClosePriceIndicator(this.doubleSeries); + final Indicator lowPrecisionClose = new ClosePriceIndicator(this.lowPrecisionSeries); - superPrecisionIndicator = new RSIIndicator(superPrecisionClose, 200); - precisionIndicator = new RSIIndicator(precisionClose, 200); - precision32Indicator = new RSIIndicator(precision32Close, 200); - doubleIndicator = new RSIIndicator(doubleClose, 200); - lowPrecisionIndicator = new RSIIndicator(lowPrecisionClose, 200); + this.superPrecisionIndicator = new RSIIndicator(superPrecisionClose, 200); + this.precisionIndicator = new RSIIndicator(precisionClose, 200); + this.precision32Indicator = new RSIIndicator(precision32Close, 200); + this.doubleIndicator = new RSIIndicator(doubleClose, 200); + this.lowPrecisionIndicator = new RSIIndicator(lowPrecisionClose, 200); calculateSuperPrecision(); calculatePrecision(); @@ -220,35 +274,37 @@ public void test() { calculateLowPrecision(); // accuracies relative to SuperPrecision - assertIndicatorEquals(superPrecisionIndicator, precisionIndicator, DecimalNum.valueOf( + assertIndicatorEquals(this.superPrecisionIndicator, this.precisionIndicator, DecimalNum.valueOf( "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); - assertIndicatorNotEquals(superPrecisionIndicator, precisionIndicator, DecimalNum.valueOf( + assertIndicatorNotEquals(this.superPrecisionIndicator, this.precisionIndicator, DecimalNum.valueOf( "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); - assertIndicatorEquals(superPrecisionIndicator, precision32Indicator, + assertIndicatorEquals(this.superPrecisionIndicator, this.precision32Indicator, DecimalNum.valueOf("0.0000000000000000000000000001")); - assertIndicatorNotEquals(superPrecisionIndicator, precision32Indicator, + assertIndicatorNotEquals(this.superPrecisionIndicator, this.precision32Indicator, DecimalNum.valueOf("0.00000000000000000000000000001")); - assertIndicatorEquals(superPrecisionIndicator, doubleIndicator, DecimalNum.valueOf("0.000000000001")); - assertIndicatorNotEquals(superPrecisionIndicator, doubleIndicator, DecimalNum.valueOf("0.0000000000001")); - assertIndicatorEquals(superPrecisionIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.5")); - assertIndicatorNotEquals(superPrecisionIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.4")); + assertIndicatorEquals(this.superPrecisionIndicator, this.doubleIndicator, DecimalNum.valueOf("0.000000000001")); + assertIndicatorNotEquals(this.superPrecisionIndicator, this.doubleIndicator, + DecimalNum.valueOf("0.0000000000001")); + assertIndicatorEquals(this.superPrecisionIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.5")); + assertIndicatorNotEquals(this.superPrecisionIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.4")); // accuracies relative to Precision - assertIndicatorEquals(precisionIndicator, precision32Indicator, + assertIndicatorEquals(this.precisionIndicator, this.precision32Indicator, DecimalNum.valueOf("0.0000000000000000000000000001")); - assertIndicatorNotEquals(precisionIndicator, precision32Indicator, + assertIndicatorNotEquals(this.precisionIndicator, this.precision32Indicator, DecimalNum.valueOf("0.00000000000000000000000000001")); - assertIndicatorEquals(precisionIndicator, doubleIndicator, DecimalNum.valueOf("0.000000000001")); - assertIndicatorNotEquals(precisionIndicator, doubleIndicator, DecimalNum.valueOf("0.0000000000001")); - assertIndicatorEquals(precisionIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.5")); - assertIndicatorNotEquals(precisionIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.4")); + assertIndicatorEquals(this.precisionIndicator, this.doubleIndicator, DecimalNum.valueOf("0.000000000001")); + assertIndicatorNotEquals(this.precisionIndicator, this.doubleIndicator, DecimalNum.valueOf("0.0000000000001")); + assertIndicatorEquals(this.precisionIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.5")); + assertIndicatorNotEquals(this.precisionIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.4")); // accuracies relative to Precision32 - assertIndicatorEquals(precision32Indicator, doubleIndicator, DecimalNum.valueOf("0.000000000001")); - assertIndicatorNotEquals(precision32Indicator, doubleIndicator, DecimalNum.valueOf("0.0000000000001")); - assertIndicatorEquals(precision32Indicator, lowPrecisionIndicator, DecimalNum.valueOf("3.5")); - assertIndicatorNotEquals(precision32Indicator, lowPrecisionIndicator, DecimalNum.valueOf("3.4")); + assertIndicatorEquals(this.precision32Indicator, this.doubleIndicator, DecimalNum.valueOf("0.000000000001")); + assertIndicatorNotEquals(this.precision32Indicator, this.doubleIndicator, + DecimalNum.valueOf("0.0000000000001")); + assertIndicatorEquals(this.precision32Indicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.5")); + assertIndicatorNotEquals(this.precision32Indicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.4")); // accuracies relative to Double - assertIndicatorEquals(doubleIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.5")); - assertIndicatorNotEquals(doubleIndicator, lowPrecisionIndicator, DecimalNum.valueOf("3.4")); + assertIndicatorEquals(this.doubleIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.5")); + assertIndicatorNotEquals(this.doubleIndicator, this.lowPrecisionIndicator, DecimalNum.valueOf("3.4")); // This helps for doing a memory snapshot // Thread.sleep(1000000); @@ -257,35 +313,35 @@ public void test() { // use separate methods for each of these for memory/CPU profiling private void calculateSuperPrecision() { - Indicator indicator = superPrecisionIndicator; + final Indicator indicator = this.superPrecisionIndicator; for (int i = indicator.getBarSeries().getBeginIndex(); i < indicator.getBarSeries().getEndIndex(); i++) { indicator.getValue(i); } } private void calculatePrecision() { - Indicator indicator = precisionIndicator; + final Indicator indicator = this.precisionIndicator; for (int i = indicator.getBarSeries().getBeginIndex(); i < indicator.getBarSeries().getEndIndex(); i++) { indicator.getValue(i); } } private void calculatePrecision32() { - Indicator indicator = precision32Indicator; + final Indicator indicator = this.precision32Indicator; for (int i = indicator.getBarSeries().getBeginIndex(); i < indicator.getBarSeries().getEndIndex(); i++) { indicator.getValue(i); } } private void calculateDouble() { - Indicator indicator = doubleIndicator; + final Indicator indicator = this.doubleIndicator; for (int i = indicator.getBarSeries().getBeginIndex(); i < indicator.getBarSeries().getEndIndex(); i++) { indicator.getValue(i); } } private void calculateLowPrecision() { - Indicator indicator = lowPrecisionIndicator; + final Indicator indicator = this.lowPrecisionIndicator; for (int i = indicator.getBarSeries().getBeginIndex(); i < indicator.getBarSeries().getEndIndex(); i++) { indicator.getValue(i); } @@ -307,7 +363,7 @@ public void testEqualsDecimalNumWithDoubleNum() { final DecimalNum decimalNum = DecimalNum.valueOf(3.0); - assertFalse(decimalNum.equals(doubleNum)); + assertNotEquals(decimalNum, doubleNum); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java index 8c0e87aa0..1ae787fe5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java @@ -41,7 +41,6 @@ import java.math.MathContext; import java.math.RoundingMode; import java.util.Properties; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.indicators.AbstractIndicatorTest; @@ -50,8 +49,8 @@ public class NumTest extends AbstractIndicatorTest { public static final int HIGH_PRECISION = 128; - public NumTest(Function numFunction) { - super(numFunction); + public NumTest(NumFactory numFactory) { + super(numFactory); } @Test @@ -353,7 +352,7 @@ public void sqrtOddExponent() { @Test public void testSerialization() throws Exception { - Num numVal = numFunction.apply(1.3); + Num numVal = numFactory.numOf(1.3); serializeDeserialize(numVal); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/BooleanIndicatorRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/BooleanIndicatorRuleTest.java index de62221f7..d11a989f9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/BooleanIndicatorRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/BooleanIndicatorRuleTest.java @@ -28,9 +28,9 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedIndicator; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class BooleanIndicatorRuleTest { @@ -38,7 +38,8 @@ public class BooleanIndicatorRuleTest { @Before public void setUp() { - Indicator indicator = new FixedIndicator(new BaseBarSeries(), true, true, false, false, true); + Indicator indicator = new FixedIndicator<>(new MockBarSeriesBuilder().build(), true, true, false, + false, true); rule = new BooleanIndicatorRule(indicator); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/ChainRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/ChainRuleTest.java index 2240031ea..93cabeea0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/ChainRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/ChainRuleTest.java @@ -28,11 +28,8 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.rules.helper.ChainLink; public class ChainRuleTest { @@ -41,11 +38,11 @@ public class ChainRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - Indicator indicator = new FixedDecimalIndicator(series, 6, 5, 8, 5, 1, 10, 2, 30); - UnderIndicatorRule underIndicatorRule = new UnderIndicatorRule(indicator, series.numOf(5)); - OverIndicatorRule overIndicatorRule = new OverIndicatorRule(indicator, 7); - IsEqualRule isEqualRule = new IsEqualRule(indicator, 5); + var series = new MockBarSeriesBuilder().build(); + var indicator = new FixedDecimalIndicator(series, 6, 5, 8, 5, 1, 10, 2, 30); + var underIndicatorRule = new UnderIndicatorRule(indicator, series.numFactory().numOf(5)); + var overIndicatorRule = new OverIndicatorRule(indicator, 7); + var isEqualRule = new IsEqualRule(indicator, 5); chainRule = new ChainRule(underIndicatorRule, new ChainLink(overIndicatorRule, 3), new ChainLink(isEqualRule, 2)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedDownIndicatorRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedDownIndicatorRuleTest.java index 27fb00d9b..5eb6a75dc 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedDownIndicatorRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedDownIndicatorRuleTest.java @@ -29,10 +29,8 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; public class CrossedDownIndicatorRuleTest { @@ -40,13 +38,13 @@ public class CrossedDownIndicatorRuleTest { @Before public void setUp() { - series = new BaseBarSeries(); + series = new BaseBarSeriesBuilder().build(); } @Test public void isSatisfied() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 12, 11, 10, 9, 11, 8, 7, 6); - CrossedDownIndicatorRule rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 12, 11, 10, 9, 11, 8, 7, 6); + var rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); @@ -60,8 +58,8 @@ public void isSatisfied() { @Test public void onlyThresholdBetweenFirstBarAndLastBar() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 11, 10, 10, 9); - CrossedDownIndicatorRule rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 11, 10, 10, 9); + var rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); @@ -71,8 +69,8 @@ public void onlyThresholdBetweenFirstBarAndLastBar() { @Test public void repeatedlyHittingThresholdAfterCrossDown() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 11, 10, 9, 10, 9, 10, 9); - CrossedDownIndicatorRule rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 11, 10, 9, 10, 9, 10, 9); + var rule = new CrossedDownIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedUpIndicatorRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedUpIndicatorRuleTest.java index 725435593..98c7331c1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedUpIndicatorRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/CrossedUpIndicatorRuleTest.java @@ -29,10 +29,8 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class CrossedUpIndicatorRuleTest { @@ -40,13 +38,13 @@ public class CrossedUpIndicatorRuleTest { @Before public void setUp() { - series = new BaseBarSeries(); + series = new MockBarSeriesBuilder().build(); } @Test public void isSatisfied() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 8, 9, 10, 12, 9, 11, 12, 13); - CrossedUpIndicatorRule rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 8, 9, 10, 12, 9, 11, 12, 13); + var rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); @@ -60,8 +58,8 @@ public void isSatisfied() { @Test public void onlyThresholdBetweenFirstBarAndLastBar() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 9, 10, 10, 10, 11); - CrossedUpIndicatorRule rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 9, 10, 10, 10, 11); + var rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); @@ -72,8 +70,8 @@ public void onlyThresholdBetweenFirstBarAndLastBar() { @Test public void repeatedlyHittingThresholdAfterCrossUp() { - Indicator evaluatedIndicator = new FixedDecimalIndicator(series, 9, 10, 11, 10, 11, 10, 11); - CrossedUpIndicatorRule rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); + var evaluatedIndicator = new FixedDecimalIndicator(series, 9, 10, 11, 10, 11, 10, 11); + var rule = new CrossedUpIndicatorRule(evaluatedIndicator, 10); assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/DayOfWeekRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/DayOfWeekRuleTest.java index 9e1a36d92..cbfa6f0f4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/DayOfWeekRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/DayOfWeekRuleTest.java @@ -29,34 +29,32 @@ import java.time.DayOfWeek; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.DateTimeIndicator; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class DayOfWeekRuleTest extends AbstractIndicatorTest { - public DayOfWeekRuleTest(Function numFunction) { - super(numFunction); + public DayOfWeekRuleTest(NumFactory numFactory) { + super(numFactory); } @Test public void isSatisfied() { final DateTimeFormatter dtf = DateTimeFormatter.ISO_ZONED_DATE_TIME; - DateTimeIndicator dateTime = new DateTimeIndicator( - new MockBarSeries(numFunction, new double[] { 100, 100, 100, 100, 100, 100, 100 }, - new ZonedDateTime[] { ZonedDateTime.parse("2019-09-16T12:00:00-00:00", dtf), // Index=0, Mon - ZonedDateTime.parse("2019-09-17T12:00:00-00:00", dtf), // 1, Tue - ZonedDateTime.parse("2019-09-18T12:00:00-00:00", dtf), // 2, Wed - ZonedDateTime.parse("2019-09-19T12:00:00-00:00", dtf), // 3, Thu - ZonedDateTime.parse("2019-09-20T12:00:00-00:00", dtf), // 4, Fri - ZonedDateTime.parse("2019-09-21T12:00:00-00:00", dtf), // 5, Sat - ZonedDateTime.parse("2019-09-22T12:00:00-00:00", dtf) // 6, Sun - }), Bar::getEndTime); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-16T12:00:00-00:00", dtf)).add(); // Index=0, Mon + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T12:00:00-00:00", dtf)).add(); // 1, Tue + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-18T12:00:00-00:00", dtf)).add(); // 2, Wed + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-19T12:00:00-00:00", dtf)).add(); // 3, Thu + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-20T12:00:00-00:00", dtf)).add(); // 4, Fri + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-21T12:00:00-00:00", dtf)).add(); // 5, Sat + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-22T12:00:00-00:00", dtf)).add(); // 6, Sun + var dateTime = new DateTimeIndicator(series, Bar::getEndTime); DayOfWeekRule rule = new DayOfWeekRule(dateTime, DayOfWeek.MONDAY, DayOfWeek.TUESDAY, DayOfWeek.WEDNESDAY, DayOfWeek.THURSDAY, DayOfWeek.FRIDAY); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/InPipeRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/InPipeRuleTest.java index 2955faa4c..ee6906ea8 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/InPipeRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/InPipeRuleTest.java @@ -28,11 +28,8 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class InPipeRuleTest { @@ -40,9 +37,9 @@ public class InPipeRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries("I am empty"); - Indicator indicator = new FixedDecimalIndicator(series, 50d, 70d, 80d, 90d, 99d, 60d, 30d, 20d, 10d, 0d); - rule = new InPipeRule(indicator, series.numOf(80), series.numOf(20)); + var series = new MockBarSeriesBuilder().withName("I am empty").build(); + var indicator = new FixedDecimalIndicator(series, 50d, 70d, 80d, 90d, 99d, 60d, 30d, 20d, 10d, 0d); + rule = new InPipeRule(indicator, series.numFactory().numOf(80), series.numFactory().numOf(20)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/InSlopeRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/InSlopeRuleTest.java index 61d111886..59887fac5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/InSlopeRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/InSlopeRuleTest.java @@ -29,7 +29,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; import org.ta4j.core.num.Num; @@ -41,10 +41,10 @@ public class InSlopeRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); + BarSeries series = new BaseBarSeriesBuilder().build(); Indicator indicator = new FixedDecimalIndicator(series, 50, 70, 80, 90, 99, 60, 30, 20, 10, 0); - rulePositiveSlope = new InSlopeRule(indicator, series.numOf(20), series.numOf(30)); - ruleNegativeSlope = new InSlopeRule(indicator, series.numOf(-40), series.numOf(-20)); + rulePositiveSlope = new InSlopeRule(indicator, series.numFactory().numOf(20), series.numFactory().numOf(30)); + ruleNegativeSlope = new InSlopeRule(indicator, series.numFactory().numOf(-40), series.numFactory().numOf(-20)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/IsEqualRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/IsEqualRuleTest.java index f040a90a2..a0546271e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/IsEqualRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/IsEqualRuleTest.java @@ -28,11 +28,8 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class IsEqualRuleTest { @@ -40,9 +37,9 @@ public class IsEqualRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - Indicator indicator = new FixedDecimalIndicator(series, 20, 10, 0, -20); - rule = new IsEqualRule(indicator, series.numOf(20)); + var series = new MockBarSeriesBuilder().build(); + var indicator = new FixedDecimalIndicator(series, 20, 10, 0, -20); + rule = new IsEqualRule(indicator, series.numFactory().numOf(20)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/IsFallingRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/IsFallingRuleTest.java index ac0f79d47..729f75ae7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/IsFallingRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/IsFallingRuleTest.java @@ -29,7 +29,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; import org.ta4j.core.num.Num; @@ -40,7 +40,7 @@ public class IsFallingRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); + BarSeries series = new BaseBarSeriesBuilder().build(); Indicator indicator = new FixedDecimalIndicator(series, 6, 5, 4, 3, 2, 1, 0, -1, 2, 3); rule = new IsFallingRule(indicator, 3); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/IsHighestRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/IsHighestRuleTest.java index 253b5e93e..ef77280f6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/IsHighestRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/IsHighestRuleTest.java @@ -28,11 +28,8 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class IsHighestRuleTest { @@ -40,8 +37,8 @@ public class IsHighestRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - Indicator indicator = new FixedDecimalIndicator(series, 1, 5, 3, 6, 5, 7, 0, -1, 2, 3); + var series = new MockBarSeriesBuilder().build(); + var indicator = new FixedDecimalIndicator(series, 1, 5, 3, 6, 5, 7, 0, -1, 2, 3); rule = new IsHighestRule(indicator, 3); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/IsLowestRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/IsLowestRuleTest.java index 3ad238ff4..6de046344 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/IsLowestRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/IsLowestRuleTest.java @@ -29,7 +29,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; import org.ta4j.core.num.Num; @@ -40,7 +40,7 @@ public class IsLowestRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); + BarSeries series = new BaseBarSeriesBuilder().build(); Indicator indicator = new FixedDecimalIndicator(series, 1, -5, 3, -6, 5, -7, 0, -1, 2, -8); rule = new IsLowestRule(indicator, 3); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/IsRisingRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/IsRisingRuleTest.java index c3ec504dc..a901468f5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/IsRisingRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/IsRisingRuleTest.java @@ -29,10 +29,8 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; public class IsRisingRuleTest { @@ -40,8 +38,8 @@ public class IsRisingRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - Indicator indicator = new FixedDecimalIndicator(series, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3); + BarSeries series = new BaseBarSeriesBuilder().build(); + var indicator = new FixedDecimalIndicator(series, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3); rule = new IsRisingRule(indicator, 3); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java index a26f4a0a1..0f4d77bba 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java @@ -27,12 +27,10 @@ import static org.junit.Assert.assertTrue; import org.junit.Test; -import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; -import org.ta4j.core.TradingRecord; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.DecimalNumFactory; public class OpenedPositionMinimumBarCountRuleTest { @@ -48,11 +46,11 @@ public void testAtLeastBarCountRuleForZeroShouldThrowException() { @Test public void testAtLeastOneBarRuleForOpenedTrade() { - final OpenedPositionMinimumBarCountRule rule = new OpenedPositionMinimumBarCountRule(1); - - final BarSeries series = new MockBarSeries(DecimalNum::valueOf, 1, 2, 3, 4); - - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); + final var rule = new OpenedPositionMinimumBarCountRule(1); + final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + .withData(1, 2, 3, 4) + .build(); + final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); assertFalse(rule.isSatisfied(0, tradingRecord)); assertTrue(rule.isSatisfied(1, tradingRecord)); @@ -62,11 +60,11 @@ public void testAtLeastOneBarRuleForOpenedTrade() { @Test public void testAtLeastMoreThanOneBarRuleForOpenedTrade() { - final OpenedPositionMinimumBarCountRule rule = new OpenedPositionMinimumBarCountRule(2); - - final BarSeries series = new MockBarSeries(DecimalNum::valueOf, 1, 2, 3, 4); - - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); + final var rule = new OpenedPositionMinimumBarCountRule(2); + final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + .withData(1, 2, 3, 4) + .build(); + final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); assertFalse(rule.isSatisfied(0, tradingRecord)); assertFalse(rule.isSatisfied(1, tradingRecord)); @@ -76,11 +74,11 @@ public void testAtLeastMoreThanOneBarRuleForOpenedTrade() { @Test public void testAtLeastBarCountRuleForClosedTradeShouldAlwaysReturnsFalse() { - final OpenedPositionMinimumBarCountRule rule = new OpenedPositionMinimumBarCountRule(1); - - final BarSeries series = new MockBarSeries(DecimalNum::valueOf, 1, 2, 3, 4); - - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series)); + final var rule = new OpenedPositionMinimumBarCountRule(1); + final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + .withData(1, 2, 3, 4) + .build(); + final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series)); assertFalse(rule.isSatisfied(0, tradingRecord)); assertFalse(rule.isSatisfied(1, tradingRecord)); @@ -90,9 +88,8 @@ public void testAtLeastBarCountRuleForClosedTradeShouldAlwaysReturnsFalse() { @Test public void testAtLeastBarCountRuleForEmptyTradingRecordShouldAlwaysReturnsFalse() { - final OpenedPositionMinimumBarCountRule rule = new OpenedPositionMinimumBarCountRule(1); - - final TradingRecord tradingRecord = new BaseTradingRecord(); + final var rule = new OpenedPositionMinimumBarCountRule(1); + final var tradingRecord = new BaseTradingRecord(); assertFalse(rule.isSatisfied(0, tradingRecord)); assertFalse(rule.isSatisfied(1, tradingRecord)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/OverIndicatorRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/OverIndicatorRuleTest.java index 8c1fa21fb..db221d75a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/OverIndicatorRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/OverIndicatorRuleTest.java @@ -29,7 +29,7 @@ import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; import org.ta4j.core.num.Num; @@ -40,9 +40,9 @@ public class OverIndicatorRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); + BarSeries series = new BaseBarSeriesBuilder().build(); Indicator indicator = new FixedDecimalIndicator(series, 20, 15, 10, 5, 0, -5, -10, 100); - rule = new OverIndicatorRule(indicator, series.numOf(5)); + rule = new OverIndicatorRule(indicator, series.numFactory().numOf(5)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/StopGainRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/StopGainRuleTest.java index cf9b4d5cf..5168f8dd2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/StopGainRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/StopGainRuleTest.java @@ -26,8 +26,6 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -36,30 +34,32 @@ import org.ta4j.core.TradingRecord; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StopGainRuleTest extends AbstractIndicatorTest { private ClosePriceIndicator closePrice; - public StopGainRuleTest(Function numFunction) { - super(numFunction); + public StopGainRuleTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - closePrice = new ClosePriceIndicator( - new MockBarSeries(numFunction, 100, 105, 110, 120, 150, 120, 160, 180, 170, 135, 104)); + closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 120, 150, 120, 160, 180, 170, 135, 104) + .build()); } @Test public void isSatisfiedWorksForBuy() { - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY); + final var tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY); final Num tradedAmount = numOf(1); // 30% stop-gain - StopGainRule rule = new StopGainRule(closePrice, numOf(30)); + var rule = new StopGainRule(closePrice, numOf(30)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); @@ -85,7 +85,7 @@ public void isSatisfiedWorksForSell() { final Num tradedAmount = numOf(1); // 30% stop-gain - StopGainRule rule = new StopGainRule(closePrice, numOf(10)); + var rule = new StopGainRule(closePrice, numOf(10)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/StopLossRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/StopLossRuleTest.java index 8da0fb46f..61d1897df 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/StopLossRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/StopLossRuleTest.java @@ -26,39 +26,39 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.function.Function; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade; -import org.ta4j.core.TradingRecord; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class StopLossRuleTest extends AbstractIndicatorTest { private ClosePriceIndicator closePrice; - public StopLossRuleTest(Function numFunction) { - super(numFunction); + public StopLossRuleTest(NumFactory numFactory) { + super(numFactory); } @Before public void setUp() { - closePrice = new ClosePriceIndicator(new MockBarSeries(numFunction, 100, 105, 110, 120, 100, 150, 110, 100)); + closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 105, 110, 120, 100, 150, 110, 100) + .build()); } @Test public void isSatisfiedWorksForBuy() { - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY); + final var tradingRecord = new BaseTradingRecord(Trade.TradeType.BUY); final Num tradedAmount = numOf(1); // 5% stop-loss - StopLossRule rule = new StopLossRule(closePrice, numOf(5)); + var rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); @@ -80,11 +80,11 @@ public void isSatisfiedWorksForBuy() { @Test public void isSatisfiedWorksForSell() { - final TradingRecord tradingRecord = new BaseTradingRecord(Trade.TradeType.SELL); + final var tradingRecord = new BaseTradingRecord(Trade.TradeType.SELL); final Num tradedAmount = numOf(1); // 5% stop-loss - StopLossRule rule = new StopLossRule(closePrice, numOf(5)); + var rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/TimeRangeRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/TimeRangeRuleTest.java index 406322f73..1cfc88580 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/TimeRangeRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/TimeRangeRuleTest.java @@ -30,38 +30,38 @@ import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Arrays; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.DateTimeIndicator; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class TimeRangeRuleTest extends AbstractIndicatorTest { - public TimeRangeRuleTest(Function numFunction) { + public TimeRangeRuleTest(NumFactory numFunction) { super(numFunction); } @Test public void isSatisfiedForBuy() { final DateTimeFormatter dtf = DateTimeFormatter.ISO_ZONED_DATE_TIME; - DateTimeIndicator dateTimeIndicator = new DateTimeIndicator( - new MockBarSeries(numFunction, new double[] { 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 }, - new ZonedDateTime[] { ZonedDateTime.parse("2019-09-17T00:00:00-00:00", dtf), // Index=0 - ZonedDateTime.parse("2019-09-17T05:00:00-00:00", dtf), // 1 - ZonedDateTime.parse("2019-09-17T07:00:00-00:00", dtf), // 2 - ZonedDateTime.parse("2019-09-17T08:00:00-00:00", dtf), // 3 - ZonedDateTime.parse("2019-09-17T15:00:00-00:00", dtf), // 4 - ZonedDateTime.parse("2019-09-17T15:05:00-00:00", dtf), // 5 - ZonedDateTime.parse("2019-09-17T16:59:00-00:00", dtf), // 6 - ZonedDateTime.parse("2019-09-17T17:05:00-00:00", dtf), // 7 - ZonedDateTime.parse("2019-09-17T23:00:00-00:00", dtf), // 8 - ZonedDateTime.parse("2019-09-17T23:30:00-00:00", dtf), // 9 - ZonedDateTime.parse("2019-09-17T23:35:00-00:00", dtf) // 10 - }), Bar::getBeginTime); + final var series = new MockBarSeriesBuilder().withNumFactory(numFactory).build(); + + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T00:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T05:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T07:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T08:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T15:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T15:05:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T16:59:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T17:05:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T23:00:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T23:30:00-00:00", dtf)).closePrice(100).add(); + series.barBuilder().endTime(ZonedDateTime.parse("2019-09-17T23:35:00-00:00", dtf)).closePrice(100).add(); + + var dateTimeIndicator = new DateTimeIndicator(series, Bar::getBeginTime); TimeRangeRule rule = new TimeRangeRule( Arrays.asList(new TimeRangeRule.TimeRange(LocalTime.of(0, 0), LocalTime.of(4, 0)), new TimeRangeRule.TimeRange(LocalTime.of(6, 0), LocalTime.of(7, 0)), diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/TrailingStopLossRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/TrailingStopLossRuleTest.java index db9c088b3..7e4358489 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/TrailingStopLossRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/TrailingStopLossRuleTest.java @@ -48,27 +48,26 @@ this software and associated documentation files (the "Software"), to deal in import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import java.util.function.Function; - import org.junit.Test; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Trade.TradeType; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; -import org.ta4j.core.mocks.MockBarSeries; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; +import org.ta4j.core.num.NumFactory; public class TrailingStopLossRuleTest extends AbstractIndicatorTest { - public TrailingStopLossRuleTest(Function numFunction) { - super(numFunction); + public TrailingStopLossRuleTest(NumFactory numFactory) { + super(numFactory); } @Test public void isSatisfiedForBuy() { BaseTradingRecord tradingRecord = new BaseTradingRecord(TradeType.BUY); - ClosePriceIndicator closePrice = new ClosePriceIndicator( - new MockBarSeries(numFunction, 100, 110, 120, 130, 117.00, 130, 116.99)); + ClosePriceIndicator closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 120, 130, 117.00, 130, 116.99) + .build()); // 10% trailing-stop-loss TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10)); @@ -93,8 +92,9 @@ public void isSatisfiedForBuy() { @Test public void isSatisfiedForBuyForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(TradeType.BUY); - ClosePriceIndicator closePrice = new ClosePriceIndicator( - new MockBarSeries(numFunction, 100, 110, 120, 130, 120, 117.00, 117.00, 130, 116.99)); + ClosePriceIndicator closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 110, 120, 130, 120, 117.00, 117.00, 130, 116.99) + .build()); // 10% trailing-stop-loss TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); @@ -121,8 +121,9 @@ public void isSatisfiedForBuyForBarCount() { @Test public void isSatisfiedForSell() { BaseTradingRecord tradingRecord = new BaseTradingRecord(TradeType.SELL); - ClosePriceIndicator closePrice = new ClosePriceIndicator( - new MockBarSeries(numFunction, 100, 90, 80, 70, 77.00, 120, 132.01)); + ClosePriceIndicator closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 90, 80, 70, 77.00, 120, 132.01) + .build()); // 10% trailing-stop-loss TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10)); @@ -148,8 +149,9 @@ public void isSatisfiedForSell() { @Test public void isSatisfiedForSellForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(TradeType.SELL); - ClosePriceIndicator closePrice = new ClosePriceIndicator( - new MockBarSeries(numFunction, 100, 90, 80, 70, 70, 73, 77.00, 90, 120, 132.01)); + ClosePriceIndicator closePrice = new ClosePriceIndicator(new MockBarSeriesBuilder().withNumFactory(numFactory) + .withData(100, 90, 80, 70, 70, 73, 77.00, 90, 120, 132.01) + .build()); // 10% trailing-stop-loss and 2 bars back TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); @@ -172,4 +174,4 @@ public void isSatisfiedForSellForBarCount() { assertFalse(rule.isSatisfied(7, tradingRecord)); assertTrue(rule.isSatisfied(8, tradingRecord)); } -} \ No newline at end of file +} diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/UnderIndicatorRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/UnderIndicatorRuleTest.java index 4d7146f33..3581bb21f 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/UnderIndicatorRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/UnderIndicatorRuleTest.java @@ -28,11 +28,8 @@ import org.junit.Before; import org.junit.Test; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; -import org.ta4j.core.Indicator; import org.ta4j.core.indicators.helpers.FixedDecimalIndicator; -import org.ta4j.core.num.Num; +import org.ta4j.core.mocks.MockBarSeriesBuilder; public class UnderIndicatorRuleTest { @@ -40,9 +37,9 @@ public class UnderIndicatorRuleTest { @Before public void setUp() { - BarSeries series = new BaseBarSeries(); - Indicator indicator = new FixedDecimalIndicator(series, 0, 5, 8, 5, 1, 10, 20, 30); - rule = new UnderIndicatorRule(indicator, series.numOf(5)); + var series = new MockBarSeriesBuilder().build(); + var indicator = new FixedDecimalIndicator(series, 0, 5, 8, 5, 1, 10, 20, 30); + rule = new UnderIndicatorRule(indicator, series.numFactory().numOf(5)); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java index c5d0e8153..d4a220d2a 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java @@ -37,23 +37,26 @@ import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.indicators.AbstractIndicatorTest; import org.ta4j.core.mocks.MockBar; +import org.ta4j.core.mocks.MockBarBuilder; +import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.NaN; import org.ta4j.core.num.Num; +import org.ta4j.core.num.NumFactory; public class BarSeriesUtilsTest extends AbstractIndicatorTest { private BarSeries series; private ZonedDateTime time; - public BarSeriesUtilsTest(Function numFunction) { - super(numFunction); + public BarSeriesUtilsTest(final NumFactory numFactory) { + super(numFactory); } /** @@ -63,15 +66,77 @@ public BarSeriesUtilsTest(Function numFunction) { public void replaceBarIfChangedTest() { final List bars = new ArrayList<>(); - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + + final Bar bar0 = new MockBarBuilder(numFactory).endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(0d) + .trades(7) + .build(); + + final Bar bar1 = new MockBarBuilder(numFactory).endTime(time.plusDays(1)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - final Bar bar2 = new MockBar(time.plusDays(2), 2d, 2d, 2d, 2d, 2d, 2d, 2, numFunction); - final Bar bar3 = new MockBar(time.plusDays(3), 3d, 3d, 3d, 3d, 3d, 3d, 3, numFunction); - final Bar bar4 = new MockBar(time.plusDays(4), 3d, 4d, 4d, 5d, 6d, 4d, 4, numFunction); - final Bar bar5 = new MockBar(time.plusDays(5), 5d, 5d, 5d, 5d, 5d, 5d, 5, numFunction); - final Bar bar6 = new MockBar(time.plusDays(6), 6d, 6d, 6d, 6d, 6d, 6d, 6, numFunction); + final Bar bar2 = new MockBarBuilder(numFactory).endTime(time.plusDays(2)) + .openPrice(2d) + .closePrice(2d) + .highPrice(2d) + .lowPrice(2d) + .amount(2d) + .volume(2d) + .trades(2) + .build(); + + final Bar bar3 = new MockBarBuilder(numFactory).endTime(time.plusDays(3)) + .openPrice(3d) + .closePrice(3d) + .highPrice(3d) + .lowPrice(3d) + .amount(3d) + .volume(3d) + .trades(3) + .build(); + + final Bar bar4 = new MockBarBuilder(numFactory).endTime(time.plusDays(4)) + .openPrice(3d) + .closePrice(4d) + .highPrice(5d) + .lowPrice(6d) + .amount(4d) + .volume(4d) + .trades(4) + .build(); + + final Bar bar5 = new MockBarBuilder(numFactory).endTime(time.plusDays(5)) + .openPrice(4d) + .closePrice(5d) + .highPrice(5d) + .lowPrice(5d) + .amount(5d) + .volume(5d) + .trades(5) + .build(); + + final Bar bar6 = new MockBarBuilder(numFactory).endTime(time.plusDays(6)) + .openPrice(6d) + .closePrice(6d) + .highPrice(6d) + .lowPrice(6d) + .amount(6d) + .volume(6d) + .trades(6) + .build(); bars.add(bar0); bars.add(bar1); @@ -81,15 +146,36 @@ public void replaceBarIfChangedTest() { bars.add(bar5); bars.add(bar6); - series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("Series Name").withBars(bars).build(); + this.series = new MockBarSeriesBuilder().withNumFactory(this.numFactory) + .withName("Series Name") + .withBars(bars) + .build(); - final Bar newBar3 = new MockBar(bar3.getEndTime(), 1d, 1d, 1d, 1d, 1d, 1d, 33, numFunction); - final Bar newBar5 = new MockBar(bar5.getEndTime(), 1d, 1d, 1d, 1d, 1d, 1d, 55, numFunction); + final var newBar3 = this.series.barBuilder() + .endTime(bar3.getEndTime()) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .volume(1d) + .trades(33) + .build(); + + final Bar newBar5 = this.series.barBuilder() + .endTime(bar5.getEndTime()) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(55) + .build(); // newBar3 must be replaced with bar3 - Bar replacedBar3 = BarSeriesUtils.replaceBarIfChanged(series, newBar3); + final Bar replacedBar3 = BarSeriesUtils.replaceBarIfChanged(this.series, newBar3); // newBar5 must be replaced with bar5 - Bar replacedBar5 = BarSeriesUtils.replaceBarIfChanged(series, newBar5); + final Bar replacedBar5 = BarSeriesUtils.replaceBarIfChanged(this.series, newBar5); // the replaced bar must be the same as the previous bar assertEquals(bar3, replacedBar3); @@ -98,32 +184,76 @@ public void replaceBarIfChangedTest() { assertNotEquals(bar6, replacedBar5); // the replaced bar must removed from the series - assertNotEquals(series.getBar(3), replacedBar3); - assertNotEquals(series.getBar(5), replacedBar5); + assertNotEquals(this.series.getBar(3), replacedBar3); + assertNotEquals(this.series.getBar(5), replacedBar5); // the new bar must be stored in the series - assertEquals(series.getBar(3), newBar3); - assertEquals(series.getBar(5), newBar5); + assertEquals(this.series.getBar(3), newBar3); + assertEquals(this.series.getBar(5), newBar5); // no bar was added - assertEquals(7, series.getBarData().size()); - assertEquals(7, series.getBarCount()); + assertEquals(7, this.series.getBarData().size()); + assertEquals(7, this.series.getBarCount()); } @Test public void findMissingBarsTest() { final List bars = new ArrayList<>(); - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); - - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - final Bar bar4 = new MockBar(time.plusDays(4), 3d, 4d, 4d, 5d, 6d, 4d, 4, numFunction); - final Bar bar5 = new MockBar(time.plusDays(5), 5d, 5d, 5d, 5d, 5d, 5d, 5, numFunction); - final Bar bar7 = new MockBar(time.plusDays(7), 0, 0, 0, 0, 0, 0, 0, numFunction); - Bar bar8 = BaseBar.builder(DoubleNum::valueOf, Double.class) - .timePeriod(Duration.ofDays(1)) - .endTime(time.plusDays(8)) + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + + final Bar bar0 = new MockBarBuilder(this.numFactory).endTime(this.time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(0d) + .trades(7) + .build(); + + final Bar bar1 = new MockBarBuilder(this.numFactory).endTime(this.time.plusDays(1)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); + + final Bar bar4 = new MockBarBuilder(this.numFactory).endTime(this.time.plusDays(4)) + .openPrice(3d) + .closePrice(4d) + .highPrice(4d) + .lowPrice(5d) + .amount(6d) + .volume(4d) + .trades(4) + .build(); + + final Bar bar5 = new MockBarBuilder(this.numFactory).endTime(this.time.plusDays(5)) + .openPrice(5d) + .closePrice(5d) + .highPrice(5d) + .lowPrice(5d) + .amount(5d) + .volume(5d) + .trades(5) + .build(); + + final Bar bar7 = new MockBarBuilder(this.numFactory).endTime(this.time.plusDays(7)) + .openPrice(0d) + .closePrice(0d) + .highPrice(0d) + .lowPrice(0d) + .amount(0d) + .volume(0d) + .trades(0) + .build(); + + final Bar bar8 = new MockBarBuilder(this.numFactory).timePeriod(Duration.ofDays(1)) + .endTime(this.time.plusDays(8)) .openPrice(NaN.NaN) .highPrice(NaN.NaN) .lowPrice(NaN.NaN) @@ -131,6 +261,7 @@ public void findMissingBarsTest() { .volume(NaN.NaN) .build(); + this.series = new BaseBarSeriesBuilder().withNumFactory(this.numFactory).withName("Series Name").build(); bars.add(bar0); bars.add(bar1); bars.add(bar4); @@ -138,15 +269,15 @@ public void findMissingBarsTest() { bars.add(bar7); bars.add(bar8); - series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("Series Name").withBars(bars).build(); + bars.forEach(series::addBar); // return the beginTime of each missing bar - List missingBars = BarSeriesUtils.findMissingBars(series, false); + final List missingBars = BarSeriesUtils.findMissingBars(this.series, false); // there must be 3 missing bars (bar2, bar3, bar6) - assertEquals(missingBars.get(0), time.plusDays(2)); - assertEquals(missingBars.get(1), time.plusDays(3)); - assertEquals(missingBars.get(2), time.plusDays(6)); + assertEquals(missingBars.get(0), this.time.plusDays(2)); + assertEquals(missingBars.get(1), this.time.plusDays(3)); + assertEquals(missingBars.get(2), this.time.plusDays(6)); // there must be 1 bar with invalid data (e.g. price, volume) assertEquals(missingBars.get(3), bar8.getEndTime()); } @@ -155,52 +286,65 @@ public void findMissingBarsTest() { public void convertBarSeriesTest() { final Function decimalNumFunction = DecimalNum::valueOf; - final Num decimalNum = DecimalNum.ZERO; - final Num doubleNum = DoubleNum.ZERO; - final Num nanNum = NaN.NaN; final List bars = new ArrayList<>(); - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); - bars.add(new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, decimalNumFunction)); - bars.add(new MockBar(time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, decimalNumFunction)); - bars.add(new MockBar(time.plusDays(2), 2d, 2d, 2d, 2d, 2d, 2d, 2, decimalNumFunction)); + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + bars.add(new MockBar(this.time, 1d, 2d, 3d, 4d, 5d, 0d, 7, decimalNumFunction)); + bars.add(new MockBar(this.time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, decimalNumFunction)); + bars.add(new MockBar(this.time.plusDays(2), 2d, 2d, 2d, 2d, 2d, 2d, 2, decimalNumFunction)); final BarSeries decimalBarSeries = new BaseBarSeriesBuilder().withBars(bars) .withMaxBarCount(100) - .withNumTypeOf(DecimalNum.class) + .withNumFactory(new DecimalNumFactory()) .withName("useDecimalNum") .build(); // convert barSeries with DecimalNum to barSeries with DoubleNum - final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, doubleNum); + final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, + new DoubleNumFactory()); // convert barSeries with DoubleNum to barSeries with DecimalNum - final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, decimalNum); - - // convert barSeries with DoubleNum to barSeries with NaNNum - final BarSeries doubleToNaNSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, nanNum); + final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, + new DecimalNumFactory()); - assertEquals(decimalBarSeries.getFirstBar().getClosePrice().getClass(), DecimalNum.class); - assertEquals(decimalToDoubleSeries.getFirstBar().getClosePrice().getClass(), DoubleNum.class); - assertEquals(doubleToDecimalSeries.getFirstBar().getClosePrice().getClass(), DecimalNum.class); - assertEquals(doubleToNaNSeries.getFirstBar().getClosePrice().getClass(), NaN.class); + assertEquals(DecimalNum.class, decimalBarSeries.getFirstBar().getClosePrice().getClass()); + assertEquals(DoubleNum.class, decimalToDoubleSeries.getFirstBar().getClosePrice().getClass()); + assertEquals(DecimalNum.class, doubleToDecimalSeries.getFirstBar().getClosePrice().getClass()); } @Test public void findOverlappingBarsTest() { final List bars = new ArrayList<>(); - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + + final Bar bar0 = new MockBarBuilder(numFactory).endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(0d) + .trades(7) + .build(); + + final Bar bar1 = new MockBarBuilder(numFactory).endTime(time) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, numFunction); - final Bar bar1 = new MockBar(time, 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - Bar bar8 = BaseBar.builder(DoubleNum::valueOf, Double.class) - .timePeriod(Duration.ofDays(1)) + final Bar bar8 = new MockBarBuilder(numFactory).timePeriod(Duration.ofDays(1)) .endTime(time.plusDays(8)) .openPrice(NaN.NaN) + .closePrice(NaN.NaN) .highPrice(NaN.NaN) .lowPrice(NaN.NaN) - .closePrice(NaN.NaN) + .amount(NaN.NaN) .volume(NaN.NaN) .build(); @@ -208,8 +352,11 @@ public void findOverlappingBarsTest() { bars.add(bar1); bars.add(bar8); - series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("Series Name").withBars(bars).build(); - List overlappingBars = BarSeriesUtils.findOverlappingBars(series); + this.series = new BaseBarSeriesBuilder().withNumFactory(this.numFactory) + .withName("Series Name") + .withBars(bars) + .build(); + final List overlappingBars = BarSeriesUtils.findOverlappingBars(this.series); // there must be 1 overlapping bars (bar1) assertEquals(overlappingBars.get(0).getBeginTime(), bar1.getBeginTime()); @@ -217,13 +364,44 @@ public void findOverlappingBarsTest() { @Test public void addBars() { - BarSeries barSeries = new BaseBarSeries("1day", numFunction.apply(0)); + final var barSeries = new MockBarSeriesBuilder().withName("1day").build(); + + final List bars = new ArrayList<>(); + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + + final Bar bar0 = barSeries.barBuilder() + .endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(0d) + .trades(7) + .build(); + + final Bar bar1 = barSeries.barBuilder() + .endTime(time.plusDays(1)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); + + final Bar bar2 = barSeries.barBuilder() + .endTime(time.plusDays(2)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); - List bars = new ArrayList<>(); - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - final Bar bar2 = new MockBar(time.plusDays(2), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); bars.add(bar2); bars.add(bar0); bars.add(bar1); @@ -234,7 +412,17 @@ public void addBars() { assertEquals(bar0.getEndTime(), barSeries.getFirstBar().getEndTime()); assertEquals(bar2.getEndTime(), barSeries.getLastBar().getEndTime()); - final Bar bar3 = new MockBar(time.plusDays(3), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); + final Bar bar3 = barSeries.barBuilder() + .endTime(time.plusDays(3)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); + bars.add(bar3); // add 1 bar to non empty barSeries @@ -244,12 +432,47 @@ public void addBars() { @Test public void sortBars() { - time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); + + final Bar bar0 = new MockBarBuilder(numFactory).endTime(time) + .openPrice(1d) + .closePrice(2d) + .highPrice(3d) + .lowPrice(4d) + .amount(5d) + .volume(0d) + .trades(7) + .build(); + + final Bar bar1 = new MockBarBuilder(numFactory).endTime(time.plusDays(1)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); - final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 0d, 7, numFunction); - final Bar bar1 = new MockBar(time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - final Bar bar2 = new MockBar(time.plusDays(2), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); - final Bar bar3 = new MockBar(time.plusDays(3), 1d, 1d, 1d, 1d, 1d, 1d, 1, numFunction); + final Bar bar2 = new MockBarBuilder(numFactory).endTime(time.plusDays(2)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); + + final Bar bar3 = new MockBarBuilder(numFactory).endTime(time.plusDays(3)) + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .amount(1d) + .volume(1d) + .trades(1) + .build(); final List sortedBars = new ArrayList<>(); sortedBars.add(bar0); diff --git a/ta4j-examples/src/main/java/ta4jexamples/Quickstart.java b/ta4j-examples/src/main/java/ta4jexamples/Quickstart.java index 5af799fdd..188436c12 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/Quickstart.java +++ b/ta4j-examples/src/main/java/ta4jexamples/Quickstart.java @@ -88,8 +88,8 @@ public static void main(String[] args) { // - or if the price loses more than 3% // - or if the price earns more than 2% Rule sellingRule = new CrossedDownIndicatorRule(shortSma, longSma) - .or(new StopLossRule(closePrice, series.numOf(3))) - .or(new StopGainRule(closePrice, series.numOf(2))); + .or(new StopLossRule(closePrice, series.numFactory().numOf(3))) + .or(new StopGainRule(closePrice, series.numFactory().numOf(2))); // Running our juicy trading strategy... BarSeriesManager seriesManager = new BarSeriesManager(series); diff --git a/ta4j-examples/src/main/java/ta4jexamples/backtesting/SimpleMovingAverageBacktest.java b/ta4j-examples/src/main/java/ta4jexamples/backtesting/SimpleMovingAverageBacktest.java index bc6406197..ae941ac74 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/backtesting/SimpleMovingAverageBacktest.java +++ b/ta4j-examples/src/main/java/ta4jexamples/backtesting/SimpleMovingAverageBacktest.java @@ -27,10 +27,10 @@ import java.time.ZoneId; import java.time.ZonedDateTime; -import org.ta4j.core.AnalysisCriterion; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarConvertibleBuilder; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.BaseStrategy; import org.ta4j.core.Strategy; import org.ta4j.core.Trade; @@ -61,7 +61,7 @@ public static void main(String[] args) throws InterruptedException { DecimalNum.valueOf(50)); System.out.println(tradingRecord2DaySma); - AnalysisCriterion criterion = new ReturnCriterion(); + var criterion = new ReturnCriterion(); Num calculate3DaySma = criterion.calculate(series, tradingRecord3DaySma); Num calculate2DaySma = criterion.calculate(series, tradingRecord2DaySma); @@ -70,22 +70,21 @@ public static void main(String[] args) throws InterruptedException { } private static BarSeries createBarSeries() { - BarSeries series = new BaseBarSeries(); - series.addBar(createBar(CreateDay(1), 100.0, 100.0, 100.0, 100.0, 1060)); - series.addBar(createBar(CreateDay(2), 110.0, 110.0, 110.0, 110.0, 1070)); - series.addBar(createBar(CreateDay(3), 140.0, 140.0, 140.0, 140.0, 1080)); - series.addBar(createBar(CreateDay(4), 119.0, 119.0, 119.0, 119.0, 1090)); - series.addBar(createBar(CreateDay(5), 100.0, 100.0, 100.0, 100.0, 1100)); - series.addBar(createBar(CreateDay(6), 110.0, 110.0, 110.0, 110.0, 1110)); - series.addBar(createBar(CreateDay(7), 120.0, 120.0, 120.0, 120.0, 1120)); - series.addBar(createBar(CreateDay(8), 130.0, 130.0, 130.0, 130.0, 1130)); + var series = new BaseBarSeriesBuilder().build(); + series.addBar(createBar(series.barBuilder(), createDay(1), 100.0, 100.0, 100.0, 100.0, 1060)); + series.addBar(createBar(series.barBuilder(), createDay(2), 110.0, 110.0, 110.0, 110.0, 1070)); + series.addBar(createBar(series.barBuilder(), createDay(3), 140.0, 140.0, 140.0, 140.0, 1080)); + series.addBar(createBar(series.barBuilder(), createDay(4), 119.0, 119.0, 119.0, 119.0, 1090)); + series.addBar(createBar(series.barBuilder(), createDay(5), 100.0, 100.0, 100.0, 100.0, 1100)); + series.addBar(createBar(series.barBuilder(), createDay(6), 110.0, 110.0, 110.0, 110.0, 1110)); + series.addBar(createBar(series.barBuilder(), createDay(7), 120.0, 120.0, 120.0, 120.0, 1120)); + series.addBar(createBar(series.barBuilder(), createDay(8), 130.0, 130.0, 130.0, 130.0, 1130)); return series; } - private static BaseBar createBar(ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, - Number closePrice, Number volume) { - return BaseBar.builder(DecimalNum::valueOf, Number.class) - .timePeriod(Duration.ofDays(1)) + private static BaseBar createBar(BaseBarConvertibleBuilder barBuilder, ZonedDateTime endTime, Number openPrice, + Number highPrice, Number lowPrice, Number closePrice, Number volume) { + return barBuilder.timePeriod(Duration.ofDays(1)) .endTime(endTime) .openPrice(openPrice) .highPrice(highPrice) @@ -95,19 +94,19 @@ private static BaseBar createBar(ZonedDateTime endTime, Number openPrice, Number .build(); } - private static ZonedDateTime CreateDay(int day) { + private static ZonedDateTime createDay(int day) { return ZonedDateTime.of(2018, 01, day, 12, 0, 0, 0, ZoneId.systemDefault()); } private static Strategy create3DaySmaStrategy(BarSeries series) { - ClosePriceIndicator closePrice = new ClosePriceIndicator(series); - SMAIndicator sma = new SMAIndicator(closePrice, 3); + var closePrice = new ClosePriceIndicator(series); + var sma = new SMAIndicator(closePrice, 3); return new BaseStrategy(new UnderIndicatorRule(sma, closePrice), new OverIndicatorRule(sma, closePrice)); } private static Strategy create2DaySmaStrategy(BarSeries series) { - ClosePriceIndicator closePrice = new ClosePriceIndicator(series); - SMAIndicator sma = new SMAIndicator(closePrice, 2); + var closePrice = new ClosePriceIndicator(series); + var sma = new SMAIndicator(closePrice, 2); return new BaseStrategy(new UnderIndicatorRule(sma, closePrice), new OverIndicatorRule(sma, closePrice)); } } diff --git a/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java b/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java index 5808fb54e..4d3b52f80 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java +++ b/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java @@ -25,19 +25,17 @@ import java.time.Duration; import java.time.ZonedDateTime; -import java.util.Arrays; -import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; import org.ta4j.core.BaseBarSeriesBuilder; -import org.ta4j.core.BaseBarConvertibleBuilder; -import org.ta4j.core.num.DecimalNum; -import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DecimalNumFactory; +import org.ta4j.core.num.DoubleNumFactory; public class BuildBarSeries { + private static final Logger LOG = LoggerFactory.getLogger(BuildBarSeries.class); /** * Calls different functions that shows how a BaseBarSeries could be created and @@ -48,86 +46,99 @@ public class BuildBarSeries { @SuppressWarnings("unused") public static void main(String[] args) { BarSeries a = buildAndAddData(); - System.out.println("a: " + a.getBar(0).getClosePrice().getName()); - BaseBarSeriesBuilder.setDefaultNum(DoubleNum::valueOf); + LOG.info("a: {}", a.getBar(0).getClosePrice().getName()); a = buildAndAddData(); - System.out.println("a: " + a.getBar(0).getClosePrice().getName()); + LOG.info("a: {}", a.getBar(0).getClosePrice().getName()); BarSeries b = buildWithDouble(); BarSeries c = buildWithBigDecimal(); BarSeries d = buildManually(); BarSeries e = buildManuallyDoubleNum(); BarSeries f = buildManuallyAndAddBarManually(); - BarSeries g = buildAndAddBarsFromList(); - // Fix: Reset default function, such that this test case does not influence the - // following test cases in a combined test run - BaseBarSeriesBuilder.setDefaultNum(DecimalNum::valueOf); } private static BarSeries buildAndAddData() { - BarSeries series = new BaseBarSeriesBuilder().withName("mySeries").build(); + var series = new BaseBarSeriesBuilder().withName("mySeries").build(); + + var endTime = ZonedDateTime.now(); + // ZonedDateTime endTime, Number openPrice, Number highPrice, Number lowPrice, + // Number closePrice, volume + addBars(series, endTime); - ZonedDateTime endTime = ZonedDateTime.now(); - series.addBar(endTime, 105.42, 112.99, 104.01, 111.42, 1337); - series.addBar(endTime.plusDays(1), 111.43, 112.83, 107.77, 107.99, 1234); - series.addBar(endTime.plusDays(2), 107.90, 117.50, 107.90, 115.42, 4242); - // ... return series; } + private static void addBars(final BarSeries series, final ZonedDateTime endTime) { + series.addBar(series.barBuilder() + .endTime(endTime) + .openPrice(105.42) + .highPrice(112.99) + .lowPrice(104.01) + .closePrice(111.42) + .volume(1337) + .build()); + series.addBar(series.barBuilder() + .endTime(endTime.plusDays(1)) + .openPrice(111.43) + .highPrice(112.83) + .lowPrice(107.77) + .closePrice(107.99) + .volume(1234) + .build()); + series.addBar(series.barBuilder() + .endTime(endTime.plusDays(2)) + .openPrice(107.90) + .highPrice(117.50) + .lowPrice(107.90) + .closePrice(115.42) + .volume(4242) + .build()); + } + private static BarSeries buildWithDouble() { - BarSeries series = new BaseBarSeriesBuilder().withName("mySeries").withNumTypeOf(DoubleNum.class).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); - ZonedDateTime endTime = ZonedDateTime.now(); - series.addBar(endTime, 105.42, 112.99, 104.01, 111.42, 1337); - series.addBar(endTime.plusDays(1), 111.43, 112.83, 107.77, 107.99, 1234); - series.addBar(endTime.plusDays(2), 107.90, 117.50, 107.90, 115.42, 4242); - // ... + var endTime = ZonedDateTime.now(); + addBars(series, endTime); return series; } private static BarSeries buildWithBigDecimal() { - BarSeries series = new BaseBarSeriesBuilder().withName("mySeries").withNumTypeOf(DecimalNum.class).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DecimalNumFactory()).build(); ZonedDateTime endTime = ZonedDateTime.now(); - series.addBar(endTime, 105.42, 112.99, 104.01, 111.42, 1337); - series.addBar(endTime.plusDays(1), 111.43, 112.83, 107.77, 107.99, 1234); - series.addBar(endTime.plusDays(2), 107.90, 117.50, 107.90, 115.42, 4242); + addBars(series, endTime); // ... return series; } private static BarSeries buildManually() { - BarSeries series = new BaseBarSeries("mySeries"); // uses BigDecimalNum + var series = new BaseBarSeriesBuilder().withName("mySeries").build(); // uses BigDecimalNum ZonedDateTime endTime = ZonedDateTime.now(); - series.addBar(endTime, 105.42, 112.99, 104.01, 111.42, 1337); - series.addBar(endTime.plusDays(1), 111.43, 112.83, 107.77, 107.99, 1234); - series.addBar(endTime.plusDays(2), 107.90, 117.50, 107.90, 115.42, 4242); + addBars(series, endTime); // ... return series; } private static BarSeries buildManuallyDoubleNum() { - BarSeries series = new BaseBarSeries("mySeries", DoubleNum.ZERO); // uses DoubleNum + var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); ZonedDateTime endTime = ZonedDateTime.now(); - series.addBar(endTime, 105.42, 112.99, 104.01, 111.42, 1337); - series.addBar(endTime.plusDays(1), 111.43, 112.83, 107.77, 107.99, 1234); - series.addBar(endTime.plusDays(2), 107.90, 117.50, 107.90, 115.42, 4242); + addBars(series, endTime); // ... return series; } private static BarSeries buildManuallyAndAddBarManually() { - BarSeries series = new BaseBarSeries("mySeries", DoubleNum.ZERO); // uses DoubleNum + var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); - // create bars and add them to the series. The bars must have the same Num type + // create bars and add them to the series. The bars have the same Num type // as the series ZonedDateTime endTime = ZonedDateTime.now(); - Bar b1 = BaseBar.builder(DoubleNum::valueOf, Double.class) + Bar b1 = series.barBuilder() .timePeriod(Duration.ofDays(1)) .endTime(endTime) .openPrice(105.42) @@ -136,7 +147,7 @@ private static BarSeries buildManuallyAndAddBarManually() { .closePrice(111.42) .volume(1337.0) .build(); - Bar b2 = BaseBar.builder(DoubleNum::valueOf, Double.class) + Bar b2 = series.barBuilder() .timePeriod(Duration.ofDays(1)) .endTime(endTime.plusDays(1)) .openPrice(111.43) @@ -145,7 +156,7 @@ private static BarSeries buildManuallyAndAddBarManually() { .closePrice(107.99) .volume(1234.0) .build(); - Bar b3 = BaseBar.builder(DoubleNum::valueOf, Double.class) + Bar b3 = series.barBuilder() .timePeriod(Duration.ofDays(1)) .endTime(endTime.plusDays(2)) .openPrice(107.90) @@ -162,45 +173,4 @@ private static BarSeries buildManuallyAndAddBarManually() { return series; } - - private static BarSeries buildAndAddBarsFromList() { - // Store Bars in a list and add them later. The bars must have the same Num type - // as the series - ZonedDateTime endTime = ZonedDateTime.now(); - Bar b1 = barBuilderFromString().timePeriod(Duration.ofDays(1)) - .endTime(endTime) - .openPrice("105.42") - .highPrice("112.99") - .lowPrice("104.01") - .closePrice("111.42") - .volume("1337") - .build(); - Bar b2 = barBuilderFromString().timePeriod(Duration.ofDays(1)) - .endTime(endTime.plusDays(1)) - .openPrice("111.43") - .highPrice("112.83") - .lowPrice("107.77") - .closePrice("107.99") - .volume("1234") - .build(); - Bar b3 = barBuilderFromString().timePeriod(Duration.ofDays(1)) - .endTime(endTime.plusDays(2)) - .openPrice("107.90") - .highPrice("117.50") - .lowPrice("107.90") - .closePrice("115.42") - .volume("4242") - .build(); - List bars = Arrays.asList(b1, b2, b3); - - return new BaseBarSeriesBuilder().withName("mySeries") - .withNumTypeOf(DoubleNum::valueOf) - .withMaxBarCount(5) - .withBars(bars) - .build(); - } - - private static BaseBarConvertibleBuilder barBuilderFromString() { - return BaseBar.builder(DoubleNum::valueOf, String.class); - } } diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java index 6b84782a4..49cd371fd 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java @@ -24,7 +24,6 @@ package ta4jexamples.loaders; import java.io.IOException; -import java.io.InputStream; import java.io.InputStreamReader; import java.nio.charset.StandardCharsets; import java.time.LocalDate; @@ -34,13 +33,12 @@ import java.util.logging.Level; import java.util.logging.Logger; -import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBarSeries; - import com.opencsv.CSVParserBuilder; import com.opencsv.CSVReader; import com.opencsv.CSVReaderBuilder; import com.opencsv.exceptions.CsvValidationException; +import org.ta4j.core.BarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; /** * This class build a Ta4j bar series from a CSV file containing bars. @@ -59,9 +57,9 @@ public static BarSeries loadAppleIncSeries() { public static BarSeries loadCsvSeries(String filename) { - InputStream stream = CsvBarsLoader.class.getClassLoader().getResourceAsStream(filename); + var stream = CsvBarsLoader.class.getClassLoader().getResourceAsStream(filename); - BarSeries series = new BaseBarSeries("apple_bars"); + var series = new BaseBarSeriesBuilder().withName("apple_bars").build(); // new CSVReader(, ',', '"', // 1) @@ -81,7 +79,14 @@ public static BarSeries loadCsvSeries(String filename) { double close = Double.parseDouble(line[4]); double volume = Double.parseDouble(line[5]); - series.addBar(date, open, high, low, close, volume); + series.addBar(series.barBuilder() + .endTime(date) + .openPrice(open) + .closePrice(close) + .highPrice(high) + .lowPrice(low) + .volume(volume) + .build()); } } catch (CsvValidationException e) { Logger.getLogger(CsvBarsLoader.class.getName()) diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java index 54036c559..782e46159 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java @@ -35,14 +35,10 @@ import java.util.logging.Level; import java.util.logging.Logger; -import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; -import org.ta4j.core.BaseBarSeries; +import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.num.Num; -import com.opencsv.CSVReader; - /** * This class builds a Ta4j bar series from a CSV file containing trades. */ @@ -58,14 +54,14 @@ public static BarSeries loadBitstampSeries() { .getResourceAsStream("bitstamp_trades_from_20131125_usd.csv"); List lines = null; assert stream != null; - try (CSVReader csvReader = new com.opencsv.CSVReader(new InputStreamReader(stream))) { + try (final var csvReader = new com.opencsv.CSVReader(new InputStreamReader(stream))) { lines = csvReader.readAll(); lines.remove(0); // Removing header line } catch (Exception ioe) { Logger.getLogger(CsvTradesLoader.class.getName()).log(Level.SEVERE, "Unable to load trades from CSV", ioe); } - BarSeries series = new BaseBarSeries(); + var series = new BaseBarSeriesBuilder().build(); if ((lines != null) && !lines.isEmpty()) { // Getting the first and last trades timestamps @@ -106,11 +102,10 @@ private static void buildSeries(BarSeries series, ZonedDateTime beginTime, Zoned ZonedDateTime barEndTime = beginTime; ListIterator iterator = lines.listIterator(); // line number of trade data - int i = 0; do { // build a bar barEndTime = barEndTime.plus(barDuration); - Bar bar = new BaseBar(barDuration, barEndTime, series.function()); + var bar = series.barBuilder().timePeriod(barDuration).endTime(barEndTime).build(); do { // get a trade String[] tradeLine = iterator.next(); @@ -119,8 +114,8 @@ private static void buildSeries(BarSeries series, ZonedDateTime beginTime, Zoned // if the trade happened during the bar if (bar.inPeriod(tradeTimeStamp)) { // add the trade to the bar - Num tradePrice = series.numOf(Double.parseDouble(tradeLine[1])); - Num tradeVolume = series.numOf(Double.parseDouble(tradeLine[2])); + Num tradePrice = series.numFactory().numOf(Double.parseDouble(tradeLine[1])); + Num tradeVolume = series.numFactory().numOf(Double.parseDouble(tradeLine[2])); bar.addTrade(tradeVolume, tradePrice); } else { // the trade happened after the end of the bar @@ -128,7 +123,6 @@ private static void buildSeries(BarSeries series, ZonedDateTime beginTime, Zoned // this break will drop us after the inner "while", skipping the increment break; } - i++; } while (iterator.hasNext()); // if the bar has any trades add it to the bars list // this is where the break drops to @@ -146,4 +140,4 @@ public static void main(String[] args) { System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tNumber of trades: " + series.getBar(0).getTrades() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } -} \ No newline at end of file +} diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java index 7a4e7de21..6b3f8fd38 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java @@ -40,7 +40,7 @@ public class GsonBarData { private Number amount; public static GsonBarData from(Bar bar) { - GsonBarData result = new GsonBarData(); + var result = new GsonBarData(); result.endTime = bar.getEndTime().toInstant().toEpochMilli(); result.openPrice = bar.getOpenPrice().getDelegate(); result.highPrice = bar.getHighPrice().getDelegate(); @@ -52,8 +52,16 @@ public static GsonBarData from(Bar bar) { } public void addTo(BaseBarSeries barSeries) { - Instant endTimeInstant = Instant.ofEpochMilli(endTime); - ZonedDateTime endBarTime = ZonedDateTime.ofInstant(endTimeInstant, ZoneId.systemDefault()); - barSeries.addBar(endBarTime, openPrice, highPrice, lowPrice, closePrice, volume, amount); + var endTimeInstant = Instant.ofEpochMilli(endTime); + var endBarTime = ZonedDateTime.ofInstant(endTimeInstant, ZoneId.systemDefault()); + barSeries.addBar(barSeries.barBuilder() + .endTime(endBarTime) + .openPrice(openPrice) + .highPrice(highPrice) + .lowPrice(lowPrice) + .closePrice(closePrice) + .volume(volume) + .amount(amount) + .build()); } } diff --git a/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java b/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java index 2fd5e6773..2b5135428 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java +++ b/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java @@ -42,7 +42,8 @@ import org.ta4j.core.indicators.helpers.HighPriceIndicator; import org.ta4j.core.indicators.helpers.LowPriceIndicator; import org.ta4j.core.num.DecimalNum; -import org.ta4j.core.num.DoubleNum; +import org.ta4j.core.num.DecimalNumFactory; +import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; import org.ta4j.core.rules.IsEqualRule; import org.ta4j.core.rules.UnderIndicatorRule; @@ -54,21 +55,44 @@ public class CompareNumTypes { public static void main(String args[]) { BaseBarSeriesBuilder barSeriesBuilder = new BaseBarSeriesBuilder(); BarSeries seriesD = barSeriesBuilder.withName("Sample Series Double ") - .withNumTypeOf(DoubleNum::valueOf) + .withNumFactory(new DoubleNumFactory()) .build(); BarSeries seriesP = barSeriesBuilder.withName("Sample Series DecimalNum 32") - .withNumTypeOf(DecimalNum::valueOf) + .withNumFactory(new DecimalNumFactory()) .build(); BarSeries seriesPH = barSeriesBuilder.withName("Sample Series DecimalNum 256") - .withNumTypeOf(number -> DecimalNum.valueOf(number.toString(), 256)) + .withNumFactory(new DecimalNumFactory() { + @Override + public Num numOf(final Number number) { + return DecimalNum.valueOf(number.toString(), 256); + } + }) .build(); int[] randoms = new Random().ints(NUMBARS, 80, 100).toArray(); for (int i = 0; i < randoms.length; i++) { ZonedDateTime date = ZonedDateTime.now().minusSeconds(NUMBARS - i); - seriesD.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); - seriesP.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); - seriesPH.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); + seriesD.addBar(seriesD.barBuilder() + .endTime(date) + .openPrice(randoms[i]) + .closePrice(randoms[i] + 21) + .highPrice(randoms[i] - 21) + .lowPrice(randoms[i] - 5) + .build()); + seriesP.addBar(seriesP.barBuilder() + .endTime(date) + .openPrice(randoms[i]) + .closePrice(randoms[i] + 21) + .highPrice(randoms[i] - 21) + .lowPrice(randoms[i] - 5) + .build()); + seriesPH.addBar(seriesPH.barBuilder() + .endTime(date) + .openPrice(randoms[i]) + .closePrice(randoms[i] + 21) + .highPrice(randoms[i] - 21) + .lowPrice(randoms[i] - 5) + .build()); } Num D = DecimalNum.valueOf(test(seriesD).toString(), 256); Num P = DecimalNum.valueOf(test(seriesP).toString(), 256); diff --git a/ta4j-examples/src/main/java/ta4jexamples/strategies/CCICorrectionStrategy.java b/ta4j-examples/src/main/java/ta4jexamples/strategies/CCICorrectionStrategy.java index 9c994396f..e3a0cb886 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/strategies/CCICorrectionStrategy.java +++ b/ta4j-examples/src/main/java/ta4jexamples/strategies/CCICorrectionStrategy.java @@ -57,8 +57,8 @@ public static Strategy buildStrategy(BarSeries series) { CCIIndicator longCci = new CCIIndicator(series, 200); CCIIndicator shortCci = new CCIIndicator(series, 5); - Num plus100 = series.hundred(); - Num minus100 = series.numOf(-100); + Num plus100 = series.numFactory().hundred(); + Num minus100 = series.numFactory().numOf(-100); Rule entryRule = new OverIndicatorRule(longCci, plus100) // Bull trend .and(new UnderIndicatorRule(shortCci, minus100)); // Signal From ebc57d70aa719c425b8e9725a70809c8deddf515 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 07:18:03 +0200 Subject: [PATCH 02/15] Reimplemented num type safety check --- .../src/main/java/org/ta4j/core/BaseBarSeries.java | 6 ++++++ .../src/main/java/org/ta4j/core/num/NumFactory.java | 10 ++++++++++ 2 files changed, 16 insertions(+) diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java index eaf7224e8..0e68a355e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java @@ -243,6 +243,12 @@ public int getRemovedBarsCount() { @Override public void addBar(final Bar bar, final boolean replace) { Objects.requireNonNull(bar, "bar must not be null"); + if (!numFactory.produces(bar.getClosePrice())) { + throw new IllegalArgumentException( + String.format("Cannot add Bar with data type: %s to series with datatype: %s", + bar.getClosePrice().getClass(), this.numFactory.one().getClass())); + } + if (!this.bars.isEmpty()) { if (replace) { this.bars.set(this.bars.size() - 1, bar); diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java index 060dee4b8..2ea4c825e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java @@ -77,4 +77,14 @@ public interface NumFactory { * @return the corresponding value as a Num implementing object */ Num numOf(String number); + + /** + * Determines whether num instace has been produced by this factory + * + * @param num to test + * @return true if made by this factory + */ + default boolean produces(Num num) { + return num == null || one().getClass() == num.getClass() || num.equals(NaN.NaN); + } } From c0b221263c6bf5674527ce516b1893b448ee4c4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 07:18:54 +0200 Subject: [PATCH 03/15] Fixed addPrice test - assumed always filled hi, lo - implementation does cont with nulls and os builder does too --- ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java index 8b4de556b..6979f223d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java @@ -27,6 +27,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.ta4j.core.TestUtils.assertNumEquals; @@ -358,14 +359,17 @@ public void addPriceTest() { Num adding1 = numOf(100); Num prevClose = defaultSeries.getBar(defaultSeries.getEndIndex() - 1).getClosePrice(); + Num currentMax = mxPrice.getValue(defaultSeries.getEndIndex()); Num currentMin = mnPrice.getValue(defaultSeries.getEndIndex()); Num currentClose = cp.getValue(defaultSeries.getEndIndex()); assertNumEquals(currentClose, defaultSeries.getLastBar().getClosePrice()); defaultSeries.addPrice(adding1); assertNumEquals(adding1, cp.getValue(defaultSeries.getEndIndex())); // adding1 is new close + assertNull(currentMax); assertNumEquals(adding1, mxPrice.getValue(defaultSeries.getEndIndex())); // adding1 also new max - assertNumEquals(currentMin, mnPrice.getValue(defaultSeries.getEndIndex())); // min stays same + assertNull(currentMin); + assertNumEquals(adding1, mnPrice.getValue(defaultSeries.getEndIndex())); // adding1 also new min assertNumEquals(prevClose, prevValue.getValue(defaultSeries.getEndIndex())); // previous close stays Num adding2 = numOf(0); From 658c888492c47667766b406f5354e82b384996af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 08:00:22 +0200 Subject: [PATCH 04/15] Implemented test time - no need to manually calculate endTime --- .../aroon/AroonDownIndicatorTest.java | 22 ------------------- .../org/ta4j/core/mocks/MockBarBuilder.java | 13 +++++++++-- 2 files changed, 11 insertions(+), 24 deletions(-) diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java index f5e19b7c9..afdd7264c 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java @@ -27,8 +27,6 @@ import static org.ta4j.core.TestUtils.assertNumEquals; import static org.ta4j.core.num.NaN.NaN; -import java.time.ZonedDateTime; - import org.junit.Before; import org.junit.Test; import org.ta4j.core.BarSeries; @@ -50,7 +48,6 @@ public AroonDownIndicatorTest(NumFactory numFunction) { public void init() { data = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("Aroon data").build(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(1)) .openPrice(168.28) .highPrice(169.87) .lowPrice(167.15) @@ -58,7 +55,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(2)) .openPrice(168.84) .highPrice(169.36) .lowPrice(168.20) @@ -66,7 +62,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(3)) .openPrice(168.88) .highPrice(169.29) .lowPrice(166.41) @@ -74,7 +69,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(4)) .openPrice(168) .highPrice(168.38) .lowPrice(166.18) @@ -82,7 +76,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(5)) .openPrice(166.89) .highPrice(167.70) .lowPrice(166.33) @@ -90,7 +83,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(6)) .openPrice(165.25) .highPrice(168.43) .lowPrice(165.00) @@ -98,7 +90,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(7)) .openPrice(168.17) .highPrice(170.18) .lowPrice(167.63) @@ -106,7 +97,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(8)) .highPrice(170.42) .lowPrice(172.15) .closePrice(170.06) @@ -114,7 +104,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(9)) .openPrice(172.41) .highPrice(172.92) .lowPrice(171.31) @@ -122,7 +111,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(10)) .openPrice(171.2) .highPrice(172.39) .lowPrice(169.55) @@ -130,7 +118,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(11)) .openPrice(170.91) .highPrice(172.48) .lowPrice(169.57) @@ -138,7 +125,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(12)) .openPrice(171.80) .highPrice(173.31) .lowPrice(170.27) @@ -146,7 +132,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(13)) .openPrice(173.09) .highPrice(173.49) .lowPrice(170.80) @@ -154,7 +139,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(14)) .openPrice(172.41) .highPrice(173.89) .lowPrice(172.20) @@ -162,7 +146,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(15)) .openPrice(173.87) .highPrice(174.17) .lowPrice(175.00) @@ -170,7 +153,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(16)) .openPrice(173.00) .highPrice(173.17) .lowPrice(172.06) @@ -178,7 +160,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(17)) .openPrice(172.26) .highPrice(172.28) .lowPrice(170.50) @@ -186,7 +167,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(18)) .openPrice(170.88) .highPrice(172.34) .lowPrice(170.26) @@ -194,7 +174,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(19)) .openPrice(171.85) .highPrice(172.07) .lowPrice(169.34) @@ -202,7 +181,6 @@ public void init() { .volume(0) .add(); data.barBuilder() - .endTime(ZonedDateTime.now().plusDays(20)) .openPrice(170.75) .highPrice(172.56) .lowPrice(170.36) diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java index 06d511201..ac3228d19 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java @@ -1,6 +1,9 @@ package org.ta4j.core.mocks; +import java.time.Clock; import java.time.Duration; +import java.time.Instant; +import java.time.ZoneId; import java.time.ZonedDateTime; import org.ta4j.core.BaseBar; @@ -12,9 +15,14 @@ */ public class MockBarBuilder extends BaseBarConvertibleBuilder { + private Clock clock = Clock.fixed(Instant.ofEpochMilli(0), ZoneId.systemDefault()); private boolean periodSet; private boolean endTimeSet; + private static long countOfProducedBars; + private Duration timePeriod; + + public MockBarBuilder(NumFactory numFactory) { super(numFactory); } @@ -28,7 +36,8 @@ public BaseBarConvertibleBuilder endTime(final ZonedDateTime endTime) { @Override public BaseBarConvertibleBuilder timePeriod(final Duration timePeriod) { periodSet = true; - return super.timePeriod(timePeriod); + this.timePeriod = timePeriod; + return super.timePeriod(this.timePeriod); } @Override @@ -38,7 +47,7 @@ public BaseBar build() { } if (!endTimeSet) { - endTime(ZonedDateTime.now()); + endTime(ZonedDateTime.now(Clock.offset(clock, timePeriod.multipliedBy(++countOfProducedBars)))); } return super.build(); } From 93dafd4a0227d16928d204bc4af856c90afb4a1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 08:01:22 +0200 Subject: [PATCH 05/15] Removed redundant constructors and enforced usage of builders --- .../src/main/java/org/ta4j/core/BaseBar.java | 117 +----------------- .../aggregator/DurationBarAggregator.java | 4 +- .../java/org/ta4j/core/BarSeriesTest.java | 6 +- .../src/test/java/org/ta4j/core/BarTest.java | 9 +- .../java/org/ta4j/core/mocks/MockBar.java | 80 ------------ .../ta4j/core/utils/BarSeriesUtilsTest.java | 23 ++-- 6 files changed, 18 insertions(+), 221 deletions(-) delete mode 100644 ta4j-core/src/test/java/org/ta4j/core/mocks/MockBar.java diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java index c59929ed5..53c080c34 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java @@ -23,16 +23,12 @@ */ package org.ta4j.core; -import java.math.BigDecimal; import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; import java.util.Objects; -import java.util.function.Function; -import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.Num; -import org.ta4j.core.num.NumFactory; /** * Base implementation of a {@link Bar}. @@ -69,116 +65,7 @@ public class BaseBar implements Bar { private Num amount; /** The number of trades of the bar period. */ - private long trades = 0; - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param numFactory the numbers factory - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, NumFactory numFactory) { - checkTimeArguments(timePeriod, endTime); - this.timePeriod = timePeriod; - this.endTime = endTime; - this.beginTime = endTime.minus(timePeriod); - this.volume = numFactory.numOf(0); - this.amount = numFactory.numOf(0); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, double openPrice, double highPrice, double lowPrice, - double closePrice, double volume) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, 0.0); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, double openPrice, double highPrice, double lowPrice, - double closePrice, double volume, double amount) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, 0, DecimalNum::valueOf); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - * @param trades the number of trades of the bar period - * @param numFunction the numbers precision - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, double openPrice, double highPrice, double lowPrice, - double closePrice, double volume, double amount, long trades, Function numFunction) { - this(timePeriod, endTime, numFunction.apply(openPrice), numFunction.apply(highPrice), - numFunction.apply(lowPrice), numFunction.apply(closePrice), numFunction.apply(volume), - numFunction.apply(amount), trades); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - * @param trades the number of trades of the bar period - * @param numFunction the numbers precision - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, String openPrice, String highPrice, String lowPrice, - String closePrice, String volume, String amount, String trades, Function numFunction) { - this(timePeriod, endTime, numFunction.apply(new BigDecimal(openPrice)), - numFunction.apply(new BigDecimal(highPrice)), numFunction.apply(new BigDecimal(lowPrice)), - numFunction.apply(new BigDecimal(closePrice)), numFunction.apply(new BigDecimal(volume)), - numFunction.apply(new BigDecimal(amount)), Integer.parseInt(trades)); - } - - /** - * Constructor. - * - * @param timePeriod the time period - * @param endTime the end time of the bar period - * @param openPrice the open price of the bar period - * @param highPrice the highest price of the bar period - * @param lowPrice the lowest price of the bar period - * @param closePrice the close price of the bar period - * @param volume the total traded volume of the bar period - * @param amount the total traded amount of the bar period - */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, - Num closePrice, Num volume, Num amount) { - this(timePeriod, endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, 0); - } + private long trades; /** * Constructor. @@ -193,7 +80,7 @@ public BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num hi * @param amount the total traded amount of the bar period * @param trades the number of trades of the bar period */ - public BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, + BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, Num volume, Num amount, long trades) { checkTimeArguments(timePeriod, endTime); this.timePeriod = timePeriod; diff --git a/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java b/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java index 1bc378fb6..ec86aa5d7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java @@ -30,6 +30,7 @@ import org.ta4j.core.Bar; import org.ta4j.core.BaseBar; +import org.ta4j.core.BaseBarBuilder; import org.ta4j.core.num.Num; /** @@ -134,8 +135,7 @@ public List aggregate(List bars) { } if (!onlyFinalBars || i <= bars.size()) { - final Bar aggregatedBar = new BaseBar(timePeriod, beginTime.plus(timePeriod), open, high, low, close, - volume, amount, trades); + final Bar aggregatedBar = new BaseBarBuilder().timePeriod(timePeriod).endTime( beginTime.plus(timePeriod)).openPrice(open).highPrice( high).lowPrice( low).closePrice( close).volume(volume).amount(amount).trades(trades).build(); aggregated.add(aggregatedBar); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java index 6979f223d..d15a505ef 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java @@ -48,9 +48,7 @@ import org.ta4j.core.indicators.helpers.LowPriceIndicator; import org.ta4j.core.indicators.helpers.PreviousValueIndicator; import org.ta4j.core.mocks.MockBarBuilderFactory; -import org.ta4j.core.num.DecimalNum; import org.ta4j.core.num.DecimalNumFactory; -import org.ta4j.core.num.DoubleNum; import org.ta4j.core.num.DoubleNumFactory; import org.ta4j.core.num.Num; import org.ta4j.core.num.NumFactory; @@ -401,13 +399,13 @@ public void addTradeTest() { @Test(expected = IllegalArgumentException.class) public void wrongBarTypeDoubleTest() { var series = new BaseBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).build(); - series.addBar(new BaseBar(Duration.ofDays(1), ZonedDateTime.now(), 1, 1, 1, 1, 1, 1, 1, DecimalNum::valueOf)); + series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)).endTime(ZonedDateTime.now()).closePrice(new DecimalNumFactory().numOf(1)).build()); } @Test(expected = IllegalArgumentException.class) public void wrongBarTypeBigDecimalTest() { var series = new BaseBarSeriesBuilder().withNumFactory(new DecimalNumFactory()).build(); - series.addBar(new BaseBar(Duration.ofDays(1), ZonedDateTime.now(), 1, 1, 1, 1, 1, 1, 1, DoubleNum::valueOf)); + series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)).endTime(ZonedDateTime.now()).closePrice(new DoubleNumFactory().numOf(1)).build()); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarTest.java index 5755db069..9b55aa2ed 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarTest.java @@ -100,16 +100,17 @@ public void inPeriod() { @Test public void equals() { - Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFactory); - Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFactory); + Bar bar1 = new BaseBarBuilder().timePeriod(Duration.ofHours(1)).endTime(endTime).build(); + Bar bar2 = new BaseBarBuilder().timePeriod(Duration.ofHours(1)).endTime(endTime).build(); assertEquals(bar1, bar2); + assertFalse(bar1 == bar2); } @Test public void hashCode2() { - Bar bar1 = new BaseBar(Duration.ofHours(1), endTime, numFactory); - Bar bar2 = new BaseBar(Duration.ofHours(1), endTime, numFactory); + Bar bar1 = new BaseBarBuilder().timePeriod(Duration.ofHours(1)).endTime(endTime).build(); + Bar bar2 = new BaseBarBuilder().timePeriod(Duration.ofHours(1)).endTime(endTime).build(); assertEquals(bar1.hashCode(), bar2.hashCode()); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBar.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBar.java deleted file mode 100644 index a05896dc7..000000000 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBar.java +++ /dev/null @@ -1,80 +0,0 @@ -/** - * The MIT License (MIT) - * - * Copyright (c) 2017-2023 Ta4j Organization & respective - * authors (see AUTHORS) - * - * Permission is hereby granted, free of charge, to any person obtaining a copy of - * this software and associated documentation files (the "Software"), to deal in - * the Software without restriction, including without limitation the rights to - * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of - * the Software, and to permit persons to whom the Software is furnished to do so, - * subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR - * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER - * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -package org.ta4j.core.mocks; - -import java.time.Duration; -import java.time.ZonedDateTime; -import java.util.function.Function; - -import org.ta4j.core.BaseBar; -import org.ta4j.core.num.Num; - -/** - * A mock bar with sample data. - */ -public class MockBar extends BaseBar { - - private static final long serialVersionUID = -4546486893163810212L; - - private long trades = 0; - - public MockBar(double closePrice, Function numFunction) { - this(ZonedDateTime.now(), closePrice, numFunction); - } - - public MockBar(double closePrice, double volume, Function numFunction) { - super(Duration.ofDays(1), ZonedDateTime.now(), 0, 0, 0, closePrice, volume, 0, 0, numFunction); - } - - public MockBar(ZonedDateTime endTime, double closePrice, Function numFunction) { - super(Duration.ofDays(1), endTime, 0, 0, 0, closePrice, 0, 0, 0, numFunction); - } - - public MockBar(ZonedDateTime endTime, double closePrice, double volume, Function numFunction) { - super(Duration.ofDays(1), endTime, 0, 0, 0, closePrice, volume, 0, 0, numFunction); - } - - public MockBar(double openPrice, double closePrice, double highPrice, double lowPrice, - Function numFunction) { - super(Duration.ofDays(1), ZonedDateTime.now(), openPrice, highPrice, lowPrice, closePrice, 1, 0, 0, - numFunction); - } - - public MockBar(double openPrice, double closePrice, double highPrice, double lowPrice, double volume, - Function numFunction) { - super(Duration.ofDays(1), ZonedDateTime.now(), openPrice, highPrice, lowPrice, closePrice, volume, 0, 0, - numFunction); - } - - public MockBar(ZonedDateTime endTime, double openPrice, double closePrice, double highPrice, double lowPrice, - double amount, double volume, long trades, Function numFunction) { - super(Duration.ofDays(1), endTime, openPrice, highPrice, lowPrice, closePrice, volume, amount, 0, numFunction); - this.trades = trades; - } - - @Override - public long getTrades() { - return trades; - } -} diff --git a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java index d4a220d2a..d7eab5f2b 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java @@ -32,14 +32,12 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import java.util.function.Function; import org.junit.Test; import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.indicators.AbstractIndicatorTest; -import org.ta4j.core.mocks.MockBar; import org.ta4j.core.mocks.MockBarBuilder; import org.ta4j.core.mocks.MockBarSeriesBuilder; import org.ta4j.core.num.DecimalNum; @@ -284,28 +282,21 @@ public void findMissingBarsTest() { @Test public void convertBarSeriesTest() { - - final Function decimalNumFunction = DecimalNum::valueOf; - - final List bars = new ArrayList<>(); - this.time = ZonedDateTime.of(2019, 6, 1, 1, 1, 0, 0, ZoneId.systemDefault()); - bars.add(new MockBar(this.time, 1d, 2d, 3d, 4d, 5d, 0d, 7, decimalNumFunction)); - bars.add(new MockBar(this.time.plusDays(1), 1d, 1d, 1d, 1d, 1d, 1d, 1, decimalNumFunction)); - bars.add(new MockBar(this.time.plusDays(2), 2d, 2d, 2d, 2d, 2d, 2d, 2, decimalNumFunction)); - - final BarSeries decimalBarSeries = new BaseBarSeriesBuilder().withBars(bars) + final BarSeries decimalBarSeries = new MockBarSeriesBuilder() .withMaxBarCount(100) .withNumFactory(new DecimalNumFactory()) .withName("useDecimalNum") .build(); + decimalBarSeries.barBuilder().openPrice(1d).closePrice(2d).highPrice(4d).lowPrice(5d).volume(0d).amount(0).trades(7).add(); + decimalBarSeries.barBuilder().openPrice(1d).closePrice(1d).highPrice(1d).lowPrice(1d).volume(1d).amount(0).trades(1).add(); + decimalBarSeries.barBuilder().openPrice(2d).closePrice(2d).highPrice(2d).lowPrice(2d).volume(2d).amount(0).trades(2).add(); + // convert barSeries with DecimalNum to barSeries with DoubleNum - final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, - new DoubleNumFactory()); + final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, new DoubleNumFactory()); // convert barSeries with DoubleNum to barSeries with DecimalNum - final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, - new DecimalNumFactory()); + final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, new DecimalNumFactory()); assertEquals(DecimalNum.class, decimalBarSeries.getFirstBar().getClosePrice().getClass()); assertEquals(DoubleNum.class, decimalToDoubleSeries.getFirstBar().getClosePrice().getClass()); From e546aa14298de745217a10c8f8833502ba46348e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 08:01:52 +0200 Subject: [PATCH 06/15] Added MIT file header --- .../ta4j/core/mocks/MockBarSeriesBuilder.java | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java index 0a63b54a7..558bc9407 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -1,3 +1,26 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core.mocks; import java.time.ZonedDateTime; @@ -11,7 +34,7 @@ import org.ta4j.core.num.NumFactory; /** - * @author Lukáš Kvídera + * Generates BaseBar implementations with mocked time or duration if not set by tester. */ public class MockBarSeriesBuilder extends BaseBarSeriesBuilder { From a20ccd6f75ab27650ad817675bf078a44dd78b4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 15:45:38 +0200 Subject: [PATCH 07/15] Fixed precision flaws of constants --- .../java/org/ta4j/core/num/DecimalNum.java | 2 +- .../org/ta4j/core/num/DecimalNumFactory.java | 46 +++++++++++++++---- .../org/ta4j/core/num/DecimalNumTest.java | 38 ++------------- 3 files changed, 42 insertions(+), 44 deletions(-) diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java index 5ae22ed83..6d6590748 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java @@ -51,7 +51,7 @@ public final class DecimalNum implements Num { private static final long serialVersionUID = 1L; - private static final int DEFAULT_PRECISION = 32; + static final int DEFAULT_PRECISION = 32; private static final Logger log = LoggerFactory.getLogger(DecimalNum.class); public static final DecimalNum MINUS_ONE = DecimalNum.valueOf(-1); diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java index 70be5c49f..42990ce7d 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java @@ -23,49 +23,77 @@ */ package org.ta4j.core.num; +import static org.ta4j.core.num.DecimalNum.DEFAULT_PRECISION; + public class DecimalNumFactory implements NumFactory { + + private final DecimalNum minusOne; + private final DecimalNum zero; + private final DecimalNum one; + private final DecimalNum two; + private final DecimalNum three; + private final DecimalNum hundred; + private final DecimalNum thousand; + private final int precision; + + public DecimalNumFactory() { + this(DEFAULT_PRECISION); + } + + public DecimalNumFactory(final int precision) { + this.precision = precision; + this.minusOne = DecimalNum.valueOf("-1", precision); + this.zero = DecimalNum.valueOf("0", precision); + this.one = DecimalNum.valueOf("1", precision); + this.two = DecimalNum.valueOf("2", precision); + this.three = DecimalNum.valueOf("3", precision); + this.hundred = DecimalNum.valueOf("100", precision); + this.thousand = DecimalNum.valueOf("1000", precision); + } + + @Override public Num minusOne() { - return DecimalNum.MINUS_ONE; + return this.minusOne; } @Override public Num zero() { - return DecimalNum.ZERO; + return this.zero; } @Override public Num one() { - return DecimalNum.ONE; + return this.one; } @Override public Num two() { - return DecimalNum.TWO; + return this.two; } @Override public Num three() { - return DecimalNum.THREE; + return this.three; } @Override public Num hundred() { - return DecimalNum.HUNDRED; + return this.hundred; } @Override public Num thousand() { - return DecimalNum.THOUSAND; + return this.thousand; } @Override public Num numOf(final Number number) { - return DecimalNum.valueOf(number); + return numOf(number.toString()); } @Override public Num numOf(final String number) { - return DecimalNum.valueOf(number); + return DecimalNum.valueOf(number, this.precision); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java index 773e37159..ed8f50cc5 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java @@ -74,42 +74,12 @@ public class DecimalNumTest { // override the auto-precision based on length of SUPER_PRECISION_STRING by // passing a precision to valueOf() - private final NumFactory superPrecisionFunc = new DecimalNumFactory() { - @Override - public Num numOf(final Number number) { - return DecimalNum.valueOf(number.toString(), 256); - } - - @Override - public Num numOf(final String number) { - return DecimalNum.valueOf(number, 256); - } - }; + private final NumFactory superPrecisionFunc = new DecimalNumFactory(256); // auto-set precision based on length of SUPER_PRECISION_STRING (120) - private final NumFactory precisionFunc = new DecimalNumFactory(); - private final NumFactory precision32Func = new DecimalNumFactory() { - @Override - public Num numOf(final Number number) { - return DecimalNum.valueOf(number.toString(), 32); - } - - @Override - public Num numOf(final String number) { - return DecimalNum.valueOf(number, 32); - } - }; + private final NumFactory precisionFunc = new DecimalNumFactory(120); + private final NumFactory precision32Func = new DecimalNumFactory(32); private final NumFactory doubleFunc = new DoubleNumFactory(); - private final NumFactory lowPrecisionFunc = new DecimalNumFactory() { - @Override - public Num numOf(final Number number) { - return DecimalNum.valueOf(number.toString(), 3); - } - - @Override - public Num numOf(final String number) { - return DecimalNum.valueOf(number, 3); - } - }; + private final NumFactory lowPrecisionFunc = new DecimalNumFactory(3); private BarSeries superPrecisionSeries; private BarSeries precisionSeries; From 4e67eb82188e42995183e1bd9f50add6275add3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 18:11:21 +0200 Subject: [PATCH 08/15] Removed constant methods from Num interface --- .../src/main/java/org/ta4j/core/BaseBar.java | 4 +- .../java/org/ta4j/core/BaseBarSeries.java | 4 +- .../org/ta4j/core/BaseBarSeriesBuilder.java | 2 +- .../src/main/java/org/ta4j/core/Position.java | 4 +- .../src/main/java/org/ta4j/core/Trade.java | 2 +- .../aggregator/DurationBarAggregator.java | 13 +- .../java/org/ta4j/core/analysis/CashFlow.java | 6 +- .../java/org/ta4j/core/analysis/Returns.java | 2 +- .../cost/FixedTransactionCostModel.java | 10 +- .../cost/LinearBorrowingCostModel.java | 9 +- .../cost/LinearTransactionCostModel.java | 2 +- .../LinearTransactionCostCriterion.java | 5 +- .../helpers/TransformIndicator.java | 4 +- .../java/org/ta4j/core/num/DecimalNum.java | 34 +--- .../org/ta4j/core/num/DecimalNumFactory.java | 63 ++++--- .../java/org/ta4j/core/num/DoubleNum.java | 29 +--- .../org/ta4j/core/num/DoubleNumFactory.java | 7 + .../src/main/java/org/ta4j/core/num/NaN.java | 57 +++++- .../src/main/java/org/ta4j/core/num/Num.java | 63 +------ .../java/org/ta4j/core/num/NumFactory.java | 2 +- .../ta4j/core/rules/TrailingStopLossRule.java | 6 +- .../java/org/ta4j/core/BarSeriesTest.java | 12 +- .../java/org/ta4j/core/SeriesBuilderTest.java | 6 +- .../test/java/org/ta4j/core/TestUtils.java | 8 +- .../aggregator/DurationBarAggregatorTest.java | 40 ++--- .../org/ta4j/core/analysis/ReturnsTest.java | 2 +- .../core/criteria/AbstractCriterionTest.java | 2 +- .../indicators/AbstractIndicatorTest.java | 11 +- .../aroon/AroonDownIndicatorTest.java | 162 +++--------------- .../org/ta4j/core/mocks/MockBarBuilder.java | 1 - .../ta4j/core/mocks/MockBarSeriesBuilder.java | 3 +- .../org/ta4j/core/num/DecimalNumTest.java | 8 +- .../test/java/org/ta4j/core/num/NumTest.java | 88 +++++----- ...OpenedPositionMinimumBarCountRuleTest.java | 6 +- .../ta4j/core/utils/BarSeriesUtilsTest.java | 41 ++++- 35 files changed, 297 insertions(+), 421 deletions(-) diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java index 53c080c34..f38d4a8f0 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBar.java @@ -80,8 +80,8 @@ public class BaseBar implements Bar { * @param amount the total traded amount of the bar period * @param trades the number of trades of the bar period */ - BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, - Num closePrice, Num volume, Num amount, long trades) { + BaseBar(Duration timePeriod, ZonedDateTime endTime, Num openPrice, Num highPrice, Num lowPrice, Num closePrice, + Num volume, Num amount, long trades) { checkTimeArguments(timePeriod, endTime); this.timePeriod = timePeriod; this.endTime = endTime; diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java index 0e68a355e..5597e84ec 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeries.java @@ -245,8 +245,8 @@ public void addBar(final Bar bar, final boolean replace) { Objects.requireNonNull(bar, "bar must not be null"); if (!numFactory.produces(bar.getClosePrice())) { throw new IllegalArgumentException( - String.format("Cannot add Bar with data type: %s to series with datatype: %s", - bar.getClosePrice().getClass(), this.numFactory.one().getClass())); + String.format("Cannot add Bar with data type: %s to series with datatype: %s", + bar.getClosePrice().getClass(), this.numFactory.one().getClass())); } if (!this.bars.isEmpty()) { diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java index 0b48ae37c..dea591c18 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarSeriesBuilder.java @@ -41,7 +41,7 @@ public class BaseBarSeriesBuilder implements BarSeriesBuilder { private String name; private boolean constrained; private int maxBarCount; - private NumFactory numFactory = new DecimalNumFactory(); + private NumFactory numFactory = DecimalNumFactory.getInstance(); private BarBuilderFactory barBuilderFactory = new BaseBarBuilderFactory(); /** Constructor to build a {@code BaseBarSeries}. */ diff --git a/ta4j-core/src/main/java/org/ta4j/core/Position.java b/ta4j-core/src/main/java/org/ta4j/core/Position.java index b81b28850..0bb989d52 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/Position.java +++ b/ta4j-core/src/main/java/org/ta4j/core/Position.java @@ -360,7 +360,7 @@ public Num getGrossReturn(Num entryPrice, Num exitPrice) { if (getEntry().isBuy()) { return exitPrice.dividedBy(entryPrice); } else { - Num one = entryPrice.numOf(1); + Num one = entryPrice.getNumFactory().one(); return ((exitPrice.dividedBy(entryPrice).minus(one)).negate()).plus(one); } } @@ -420,7 +420,7 @@ public TradeType getStartingType() { * @return the Num of 0 */ private Num zero() { - return entry.getNetPrice().zero(); + return entry.getNetPrice().getNumFactory().zero(); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/Trade.java b/ta4j-core/src/main/java/org/ta4j/core/Trade.java index 6673727ee..2edfb1a47 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/Trade.java +++ b/ta4j-core/src/main/java/org/ta4j/core/Trade.java @@ -143,7 +143,7 @@ protected Trade(int index, BarSeries series, TradeType type, Num amount, CostMod * @param pricePerAsset the trade price per asset */ protected Trade(int index, TradeType type, Num pricePerAsset) { - this(index, type, pricePerAsset, pricePerAsset.one()); + this(index, type, pricePerAsset, pricePerAsset.getNumFactory().one()); } /** diff --git a/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java b/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java index ec86aa5d7..8dda856d4 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/aggregator/DurationBarAggregator.java @@ -91,7 +91,7 @@ public List aggregate(List bars) { } int i = 0; - final Num zero = firstBar.getOpenPrice().zero(); + final Num zero = firstBar.getOpenPrice().getNumFactory().zero(); while (i < bars.size()) { Bar bar = bars.get(i); final ZonedDateTime beginTime = bar.getBeginTime(); @@ -135,7 +135,16 @@ public List aggregate(List bars) { } if (!onlyFinalBars || i <= bars.size()) { - final Bar aggregatedBar = new BaseBarBuilder().timePeriod(timePeriod).endTime( beginTime.plus(timePeriod)).openPrice(open).highPrice( high).lowPrice( low).closePrice( close).volume(volume).amount(amount).trades(trades).build(); + final Bar aggregatedBar = new BaseBarBuilder().timePeriod(timePeriod) + .endTime(beginTime.plus(timePeriod)) + .openPrice(open) + .highPrice(high) + .lowPrice(low) + .closePrice(close) + .volume(volume) + .amount(amount) + .trades(trades) + .build(); aggregated.add(aggregatedBar); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java index 293b969c3..ce880a4bb 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/CashFlow.java @@ -141,12 +141,12 @@ private void calculate(Position position, int finalIndex) { values.addAll(Collections.nCopies(begin - values.size(), lastValue)); } // Trade is not valid if net balance at the entryIndex is negative - if (values.get(values.size() - 1).isGreaterThan(values.get(0).numOf(0))) { + if (values.get(values.size() - 1).isGreaterThan(values.get(0).getNumFactory().numOf(0))) { int startingIndex = Math.max(begin, 1); int nPeriods = endIndex - entryIndex; Num holdingCost = position.getHoldingCost(endIndex); - Num avgCost = holdingCost.dividedBy(holdingCost.numOf(nPeriods)); + Num avgCost = holdingCost.dividedBy(holdingCost.getNumFactory().numOf(nPeriods)); // Add intermediate cash flows during position Num netEntryPrice = position.getEntry().getNetPrice(); @@ -180,7 +180,7 @@ private static Num getIntermediateRatio(boolean isLongTrade, Num entryPrice, Num if (isLongTrade) { ratio = exitPrice.dividedBy(entryPrice); } else { - ratio = entryPrice.numOf(2).minus(exitPrice.dividedBy(entryPrice)); + ratio = entryPrice.getNumFactory().numOf(2).minus(exitPrice.dividedBy(entryPrice)); } return ratio; diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java index eb58e59e6..c2faacbe9 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/Returns.java @@ -162,7 +162,7 @@ public void calculate(Position position, int finalIndex) { int startingIndex = Math.max(begin, 1); int nPeriods = endIndex - entryIndex; Num holdingCost = position.getHoldingCost(endIndex); - Num avgCost = holdingCost.dividedBy(holdingCost.numOf(nPeriods)); + Num avgCost = holdingCost.dividedBy(getBarSeries().numFactory().numOf(nPeriods)); // returns are per period (iterative). Base price needs to be updated // accordingly diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/FixedTransactionCostModel.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/FixedTransactionCostModel.java index 58e583244..f3c471489 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/FixedTransactionCostModel.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/FixedTransactionCostModel.java @@ -58,12 +58,12 @@ public FixedTransactionCostModel(double feePerTrade) { */ @Override public Num calculate(Position position, int currentIndex) { - Num pricePerAsset = position.getEntry().getPricePerAsset(); - Num multiplier = pricePerAsset.one(); + final var numFactory = position.getEntry().getPricePerAsset().getNumFactory(); + Num multiplier = numFactory.one(); if (position.isClosed()) { - multiplier = pricePerAsset.numOf(2); + multiplier = numFactory.numOf(2); } - return pricePerAsset.numOf(feePerTrade).multipliedBy(multiplier); + return numFactory.numOf(feePerTrade).multipliedBy(multiplier); } /** @@ -82,7 +82,7 @@ public Num calculate(Position position) { */ @Override public Num calculate(Num price, Num amount) { - return price.numOf(feePerTrade); + return price.getNumFactory().numOf(feePerTrade); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearBorrowingCostModel.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearBorrowingCostModel.java index b875de4e7..867d06ad9 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearBorrowingCostModel.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearBorrowingCostModel.java @@ -50,7 +50,7 @@ public LinearBorrowingCostModel(double feePerPeriod) { */ @Override public Num calculate(Num price, Num amount) { - return price.zero(); + return price.getNumFactory().zero(); } /** @@ -73,7 +73,7 @@ public Num calculate(Position position) { public Num calculate(Position position, int currentIndex) { Trade entryTrade = position.getEntry(); Trade exitTrade = position.getExit(); - Num borrowingCost = position.getEntry().getNetPrice().zero(); + Num borrowingCost = position.getEntry().getNetPrice().getNumFactory().zero(); // Borrowing costs only apply to short positions. if (entryTrade != null && entryTrade.getType().equals(Trade.TradeType.SELL) && entryTrade.getAmount() != null) { @@ -94,8 +94,9 @@ public Num calculate(Position position, int currentIndex) { * @return the absolute borrowing cost */ private Num getHoldingCostForPeriods(int tradingPeriods, Num tradedValue) { - return tradedValue - .multipliedBy(tradedValue.numOf(tradingPeriods).multipliedBy(tradedValue.numOf(feePerPeriod))); + return tradedValue.multipliedBy(tradedValue.getNumFactory() + .numOf(tradingPeriods) + .multipliedBy(tradedValue.getNumFactory().numOf(feePerPeriod))); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearTransactionCostModel.java b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearTransactionCostModel.java index d2297c45e..43df2f276 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearTransactionCostModel.java +++ b/ta4j-core/src/main/java/org/ta4j/core/analysis/cost/LinearTransactionCostModel.java @@ -73,7 +73,7 @@ public Num calculate(Position position) { @Override public Num calculate(Num price, Num amount) { - return amount.numOf(feePerPosition).multipliedBy(price).multipliedBy(amount); + return amount.getNumFactory().numOf(feePerPosition).multipliedBy(price).multipliedBy(amount); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java b/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java index 83b69b1a7..e0514fba7 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java +++ b/ta4j-core/src/main/java/org/ta4j/core/criteria/LinearTransactionCostCriterion.java @@ -116,9 +116,10 @@ public boolean betterThan(Num criterionValue1, Num criterionValue2) { * @return the absolute trade cost */ private Num getTradeCost(Trade trade, Num tradedAmount) { - Num tradeCost = tradedAmount.zero(); + final var numFactory = tradedAmount.getNumFactory(); + Num tradeCost = numFactory.zero(); if (trade != null) { - return tradedAmount.numOf(a).multipliedBy(tradedAmount).plus(tradedAmount.numOf(b)); + return numFactory.numOf(a).multipliedBy(tradedAmount).plus(numFactory.numOf(b)); } return tradeCost; } diff --git a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java index dcff1a6c3..5992ae084 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java +++ b/ta4j-core/src/main/java/org/ta4j/core/indicators/helpers/TransformIndicator.java @@ -28,6 +28,7 @@ import org.ta4j.core.Indicator; import org.ta4j.core.indicators.CachedIndicator; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.Num; /** @@ -144,7 +145,8 @@ public static TransformIndicator sqrt(Indicator indicator) { * underlying doubleValue method */ public static TransformIndicator log(Indicator indicator) { - return new TransformIndicator(indicator, val -> val.numOf(Math.log(val.doubleValue()))); + return new TransformIndicator(indicator, + val -> DecimalNumFactory.getInstance().numOf(Math.log(val.doubleValue()))); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java index 6d6590748..363288292 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNum.java @@ -32,7 +32,6 @@ import java.text.ParseException; import java.util.Locale; import java.util.Objects; -import java.util.function.Function; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -54,14 +53,6 @@ public final class DecimalNum implements Num { static final int DEFAULT_PRECISION = 32; private static final Logger log = LoggerFactory.getLogger(DecimalNum.class); - public static final DecimalNum MINUS_ONE = DecimalNum.valueOf(-1); - public static final DecimalNum ZERO = DecimalNum.valueOf(0); - public static final DecimalNum ONE = DecimalNum.valueOf(1); - public static final DecimalNum TWO = DecimalNum.valueOf(2); - public static final DecimalNum THREE = DecimalNum.valueOf(3); - public static final DecimalNum HUNDRED = DecimalNum.valueOf(100); - public static final DecimalNum THOUSAND = DecimalNum.valueOf(1000); - private final MathContext mathContext; private final BigDecimal delegate; @@ -288,26 +279,6 @@ public static DecimalNum valueOf(BigDecimal val, int precision) { return new DecimalNum(val, precision); } - @Override - public Num zero() { - return mathContext.getPrecision() == DEFAULT_PRECISION ? ZERO : function().apply(0); - } - - @Override - public Num one() { - return mathContext.getPrecision() == DEFAULT_PRECISION ? ONE : function().apply(1); - } - - @Override - public Num hundred() { - return mathContext.getPrecision() == DEFAULT_PRECISION ? HUNDRED : function().apply(100); - } - - @Override - public Function function() { - return (number -> DecimalNum.valueOf(number.toString(), mathContext.getPrecision())); - } - /** * Returns the underlying {@link BigDecimal} delegate. * @@ -318,6 +289,11 @@ public BigDecimal getDelegate() { return delegate; } + @Override + public NumFactory getNumFactory() { + return DecimalNumFactory.getInstance(mathContext.getPrecision()); + } + /** * Returns the underlying {@link MathContext} mathContext. * diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java index 42990ce7d..e7b036bd9 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java @@ -25,66 +25,64 @@ import static org.ta4j.core.num.DecimalNum.DEFAULT_PRECISION; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + public class DecimalNumFactory implements NumFactory { - private final DecimalNum minusOne; - private final DecimalNum zero; - private final DecimalNum one; - private final DecimalNum two; - private final DecimalNum three; - private final DecimalNum hundred; - private final DecimalNum thousand; + /** + * prebuilt constants with defined precisions + */ + private static final Map> decimalNums = new ConcurrentHashMap<>(); + + /** + * factory singletons for specific precisions + */ + private static final Map factories = new ConcurrentHashMap<>(); + private final int precision; - public DecimalNumFactory() { - this(DEFAULT_PRECISION); + private DecimalNumFactory() { + this(DEFAULT_PRECISION); } - public DecimalNumFactory(final int precision) { + private DecimalNumFactory(final int precision) { this.precision = precision; - this.minusOne = DecimalNum.valueOf("-1", precision); - this.zero = DecimalNum.valueOf("0", precision); - this.one = DecimalNum.valueOf("1", precision); - this.two = DecimalNum.valueOf("2", precision); - this.three = DecimalNum.valueOf("3", precision); - this.hundred = DecimalNum.valueOf("100", precision); - this.thousand = DecimalNum.valueOf("1000", precision); } - @Override public Num minusOne() { - return this.minusOne; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("-1"); } @Override public Num zero() { - return this.zero; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("0"); } @Override public Num one() { - return this.one; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("1"); } @Override public Num two() { - return this.two; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("2"); } @Override public Num three() { - return this.three; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("3"); } @Override public Num hundred() { - return this.hundred; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("100"); } @Override public Num thousand() { - return this.thousand; + return decimalNums.computeIfAbsent(this.precision, DecimalNumFactory::initConstants).get("1000"); } @Override @@ -96,4 +94,19 @@ public Num numOf(final Number number) { public Num numOf(final String number) { return DecimalNum.valueOf(number, this.precision); } + + private static Map initConstants(final int precision) { + return Map.of("-1", DecimalNum.valueOf("-1", precision), "0", DecimalNum.valueOf("0", precision), "1", + DecimalNum.valueOf("1", precision), "2", DecimalNum.valueOf("2", precision), "3", + DecimalNum.valueOf("3", precision), "100", DecimalNum.valueOf("100", precision), "1000", + DecimalNum.valueOf("1000", precision)); + } + + public static NumFactory getInstance() { + return getInstance(DEFAULT_PRECISION); + } + + public static NumFactory getInstance(final int precision) { + return factories.computeIfAbsent(precision, DecimalNumFactory::new); + } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java index ceb4aff8e..1d5297645 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNum.java @@ -25,8 +25,6 @@ import static org.ta4j.core.num.NaN.NaN; -import java.util.function.Function; - /** * Representation of {@link Double}. High performance, lower precision. * @@ -93,7 +91,7 @@ public static DoubleNum valueOf(DecimalNum val) { * @return the {@code Num} */ public static DoubleNum valueOf(int val) { - return new DoubleNum((double) val); + return new DoubleNum(val); } /** @@ -103,7 +101,7 @@ public static DoubleNum valueOf(int val) { * @return the {@code Num} */ public static DoubleNum valueOf(long val) { - return new DoubleNum((double) val); + return new DoubleNum(val); } /** @@ -113,7 +111,7 @@ public static DoubleNum valueOf(long val) { * @return the {@code Num} */ public static DoubleNum valueOf(short val) { - return new DoubleNum((double) val); + return new DoubleNum(val); } /** @@ -127,27 +125,12 @@ public static DoubleNum valueOf(short val) { * value of {@code val}. */ public static DoubleNum valueOf(float val) { - return new DoubleNum((double) val); - } - - @Override - public Num zero() { - return ZERO; - } - - @Override - public Num one() { - return ONE; - } - - @Override - public Num hundred() { - return HUNDRED; + return new DoubleNum(val); } @Override - public Function function() { - return DoubleNum::valueOf; + public NumFactory getNumFactory() { + return DoubleNumFactory.getInstance(); } @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java index 4b60b51f6..3edf7d5fc 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java @@ -24,6 +24,9 @@ package org.ta4j.core.num; public class DoubleNumFactory implements NumFactory { + + private static final DoubleNumFactory DOUBLE_NUM_FACTORY = new DoubleNumFactory(); + @Override public Num minusOne() { return DoubleNum.MINUS_ONE; @@ -68,4 +71,8 @@ public Num numOf(final Number number) { public Num numOf(final String number) { return DoubleNum.valueOf(number); } + + public static DoubleNumFactory getInstance() { + return DOUBLE_NUM_FACTORY; + } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NaN.java b/ta4j-core/src/main/java/org/ta4j/core/num/NaN.java index e7806ba65..7ba71fa9b 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/NaN.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NaN.java @@ -23,8 +23,6 @@ */ package org.ta4j.core.num; -import java.util.function.Function; - /** * Representation of an undefined or unrepresentable value: NaN (not a number) * @@ -96,6 +94,56 @@ public Number getDelegate() { return null; } + @Override + public NumFactory getNumFactory() { + return new NumFactory() { + @Override + public Num minusOne() { + return NaN; + } + + @Override + public Num zero() { + return NaN; + } + + @Override + public Num one() { + return NaN; + } + + @Override + public Num two() { + return NaN; + } + + @Override + public Num three() { + return NaN; + } + + @Override + public Num hundred() { + return NaN; + } + + @Override + public Num thousand() { + return NaN; + } + + @Override + public Num numOf(final Number number) { + return NaN; + } + + @Override + public Num numOf(final String number) { + return NaN; + } + }; + } + @Override public String getName() { return toString(); @@ -243,11 +291,6 @@ public Num max(Num other) { return this; } - @Override - public Function function() { - return number -> NaN; - } - @Override public boolean isNaN() { return true; diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/Num.java b/ta4j-core/src/main/java/org/ta4j/core/num/Num.java index 6c91b131f..79921fdbe 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/Num.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/Num.java @@ -24,48 +24,26 @@ package org.ta4j.core.num; import java.io.Serializable; -import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; -import java.util.function.Function; /** * Ta4js definition of operations that must be fulfilled by an object that * should be used as base for calculations. * * @see Num - * @see Num#function() * @see DoubleNum * @see DecimalNum */ public interface Num extends Comparable, Serializable { - // TODO remove constants /** - * @return the Num of 0 - */ - default Num zero() { - return numOf(0); - } - - /** - * @return the Num of 1 - */ - default Num one() { - return numOf(1); - } - - /** - * @return the Num of 100 + * @return the delegate used from this {@code Num} implementation */ - default Num hundred() { - return numOf(100); - } + Number getDelegate(); /** - * @return the delegate used from this {@code Num} implementation + * @return factory that created this instance with defined precision */ - Number getDelegate(); + NumFactory getNumFactory(); /** * Returns the name/description of this Num implementation. @@ -277,39 +255,6 @@ default Num hundred() { */ Num max(Num other); - /** - * Returns the {@link Function} to convert a number instance into the - * corresponding Num instance. - * - * @return function which converts a number instance into the corresponding Num - * instance - */ - Function function(); - - /** - * Transforms a {@link Number} into a new Num instance of this {@code Num} - * implementation. - * - * @param value the Number to transform - * @return the corresponding Num implementation of the {@code value} - */ - default Num numOf(Number value) { - return function().apply(value); - } - - /** - * Transforms a {@link String} into a new Num instance of this {@code Num} - * implementation with a precision. - * - * @param value the String to transform - * @param precision the precision - * @return the corresponding Num implementation of the {@code value} - */ - default Num numOf(String value, int precision) { - MathContext mathContext = new MathContext(precision, RoundingMode.HALF_UP); - return this.numOf(new BigDecimal(value, mathContext)); - } - /** * Returns true only if {@code this} is an instance of {@link NaN}. * diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java index 2ea4c825e..5becf96fe 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java @@ -85,6 +85,6 @@ public interface NumFactory { * @return true if made by this factory */ default boolean produces(Num num) { - return num == null || one().getClass() == num.getClass() || num.equals(NaN.NaN); + return num == null || one().getClass() == num.getClass() || num.equals(NaN.NaN); } } diff --git a/ta4j-core/src/main/java/org/ta4j/core/rules/TrailingStopLossRule.java b/ta4j-core/src/main/java/org/ta4j/core/rules/TrailingStopLossRule.java index fc1208d91..ff8f30976 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/rules/TrailingStopLossRule.java +++ b/ta4j-core/src/main/java/org/ta4j/core/rules/TrailingStopLossRule.java @@ -96,7 +96,8 @@ private boolean isBuySatisfied(Num currentPrice, int index, int positionIndex) { HighestValueIndicator highest = new HighestValueIndicator(priceIndicator, getValueIndicatorBarCount(index, positionIndex)); Num highestCloseNum = highest.getValue(index); - Num lossRatioThreshold = highestCloseNum.numOf(100).minus(lossPercentage).dividedBy(highestCloseNum.numOf(100)); + final var hundred = highestCloseNum.getNumFactory().hundred(); + Num lossRatioThreshold = hundred.minus(lossPercentage).dividedBy(hundred); Num currentStopLossLimitActivation = highestCloseNum.multipliedBy(lossRatioThreshold); return currentPrice.isLessThanOrEqual(currentStopLossLimitActivation); } @@ -105,7 +106,8 @@ private boolean isSellSatisfied(Num currentPrice, int index, int positionIndex) LowestValueIndicator lowest = new LowestValueIndicator(priceIndicator, getValueIndicatorBarCount(index, positionIndex)); Num lowestCloseNum = lowest.getValue(index); - Num lossRatioThreshold = lowestCloseNum.numOf(100).plus(lossPercentage).dividedBy(lowestCloseNum.numOf(100)); + final var hundred = lowestCloseNum.getNumFactory().hundred(); + Num lossRatioThreshold = hundred.plus(lossPercentage).dividedBy(hundred); Num currentStopLossLimitActivation = lowestCloseNum.multipliedBy(lossRatioThreshold); return currentPrice.isGreaterThanOrEqual(currentStopLossLimitActivation); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java index d15a505ef..4144db237 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java @@ -399,13 +399,19 @@ public void addTradeTest() { @Test(expected = IllegalArgumentException.class) public void wrongBarTypeDoubleTest() { var series = new BaseBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).build(); - series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)).endTime(ZonedDateTime.now()).closePrice(new DecimalNumFactory().numOf(1)).build()); + series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now()) + .closePrice(DecimalNumFactory.getInstance().numOf(1)) + .build()); } @Test(expected = IllegalArgumentException.class) public void wrongBarTypeBigDecimalTest() { - var series = new BaseBarSeriesBuilder().withNumFactory(new DecimalNumFactory()).build(); - series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)).endTime(ZonedDateTime.now()).closePrice(new DoubleNumFactory().numOf(1)).build()); + var series = new BaseBarSeriesBuilder().withNumFactory(DecimalNumFactory.getInstance()).build(); + series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now()) + .closePrice(new DoubleNumFactory().numOf(1)) + .build()); } @Test diff --git a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java index fe5e4ba26..c77af20fd 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java @@ -38,7 +38,7 @@ public class SeriesBuilderTest { private final BaseBarSeriesBuilder seriesBuilder = new BaseBarSeriesBuilder() - .withNumFactory(new DecimalNumFactory()); + .withNumFactory(DecimalNumFactory.getInstance()); @Test public void testBuilder() { @@ -50,7 +50,7 @@ public void testBuilder() { .withName("useDoubleNum") .build(); BarSeries precisionSeries = seriesBuilder.withMaxBarCount(100) - .withNumFactory(new DecimalNumFactory()) + .withNumFactory(DecimalNumFactory.getInstance()) .withName("usePrecisionNum") .build(); @@ -108,7 +108,7 @@ public void testNumFunctions() { @Test public void testWrongNumType() { - BarSeries series = seriesBuilder.withNumFactory(new DecimalNumFactory()).build(); + BarSeries series = seriesBuilder.withNumFactory(DecimalNumFactory.getInstance()).build(); assertNumEquals(series.numFactory().numOf(12), DecimalNum.valueOf(12)); } } diff --git a/ta4j-core/src/test/java/org/ta4j/core/TestUtils.java b/ta4j-core/src/test/java/org/ta4j/core/TestUtils.java index accefa433..c6a57f1a1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/TestUtils.java +++ b/ta4j-core/src/test/java/org/ta4j/core/TestUtils.java @@ -54,7 +54,7 @@ public class TestUtils { * {@code String} representation */ public static void assertNumEquals(String expected, Num actual) { - assertEquals(actual.numOf(new BigDecimal(expected)), actual); + assertEquals(actual.getNumFactory().numOf(new BigDecimal(expected)), actual); } /** @@ -85,7 +85,7 @@ public static void assertNumEquals(int expected, Num actual) { if (actual.isNaN()) { throw new AssertionError("Expected: " + expected + " Actual: " + actual); } - assertEquals(actual.numOf(expected), actual); + assertEquals(actual.getNumFactory().numOf(expected), actual); } /** @@ -113,7 +113,7 @@ public static void assertNumEquals(double expected, Num actual) { * representation */ public static void assertNumNotEquals(int unexpected, Num actual) { - assertNotEquals(actual.numOf(unexpected), actual); + assertNotEquals(actual.getNumFactory().numOf(unexpected), actual); } /** @@ -159,7 +159,7 @@ public static void assertIndicatorNotEquals(Indicator expected, Indicator function() { - return List.of(new DoubleNumFactory(), new DecimalNumFactory()); + return List.of(new DoubleNumFactory(), DecimalNumFactory.getInstance()); } /** diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java index 31c3db4bb..535a13439 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java @@ -23,9 +23,6 @@ */ package org.ta4j.core.indicators; -import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; import java.util.List; import org.junit.runner.RunWith; @@ -59,7 +56,7 @@ public abstract class AbstractIndicatorTest { @Parameterized.Parameters(name = "Test Case: {index} (0=DoubleNum, 1=DecimalNum)") public static List function() { - return List.of(new DoubleNumFactory(), new DecimalNumFactory()); + return List.of(new DoubleNumFactory(), DecimalNumFactory.getInstance()); } private final IndicatorFactory factory; @@ -103,10 +100,4 @@ public Indicator getIndicator(D data, Object... params) { protected Num numOf(Number n) { return numFactory.numOf(n); } - - public Num numOf(String string, int precision) { - var mathContext = new MathContext(precision, RoundingMode.HALF_UP); - return this.numOf(new BigDecimal(string, mathContext)); - } - } diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java index afdd7264c..d1fdc9e46 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/aroon/AroonDownIndicatorTest.java @@ -47,146 +47,28 @@ public AroonDownIndicatorTest(NumFactory numFunction) { @Before public void init() { data = new MockBarSeriesBuilder().withNumFactory(numFactory).withName("Aroon data").build(); - data.barBuilder() - .openPrice(168.28) - .highPrice(169.87) - .lowPrice(167.15) - .closePrice(169.64) - .volume(0) - .add(); - data.barBuilder() - .openPrice(168.84) - .highPrice(169.36) - .lowPrice(168.20) - .closePrice(168.71) - .volume(0) - .add(); - data.barBuilder() - .openPrice(168.88) - .highPrice(169.29) - .lowPrice(166.41) - .closePrice(167.74) - .volume(0) - .add(); - data.barBuilder() - .openPrice(168) - .highPrice(168.38) - .lowPrice(166.18) - .closePrice(166.32) - .volume(0) - .add(); - data.barBuilder() - .openPrice(166.89) - .highPrice(167.70) - .lowPrice(166.33) - .closePrice(167.24) - .volume(0) - .add(); - data.barBuilder() - .openPrice(165.25) - .highPrice(168.43) - .lowPrice(165.00) - .closePrice(168.05) - .volume(0) - .add(); - data.barBuilder() - .openPrice(168.17) - .highPrice(170.18) - .lowPrice(167.63) - .closePrice(169.92) - .volume(0) - .add(); - data.barBuilder() - .highPrice(170.42) - .lowPrice(172.15) - .closePrice(170.06) - .lowPrice(171.97) - .volume(0) - .add(); - data.barBuilder() - .openPrice(172.41) - .highPrice(172.92) - .lowPrice(171.31) - .closePrice(172.02) - .volume(0) - .add(); - data.barBuilder() - .openPrice(171.2) - .highPrice(172.39) - .lowPrice(169.55) - .closePrice(170.72) - .volume(0) - .add(); - data.barBuilder() - .openPrice(170.91) - .highPrice(172.48) - .lowPrice(169.57) - .closePrice(172.09) - .volume(0) - .add(); - data.barBuilder() - .openPrice(171.80) - .highPrice(173.31) - .lowPrice(170.27) - .closePrice(173.21) - .volume(0) - .add(); - data.barBuilder() - .openPrice(173.09) - .highPrice(173.49) - .lowPrice(170.80) - .closePrice(170.95) - .volume(0) - .add(); - data.barBuilder() - .openPrice(172.41) - .highPrice(173.89) - .lowPrice(172.20) - .closePrice(173.51) - .volume(0) - .add(); - data.barBuilder() - .openPrice(173.87) - .highPrice(174.17) - .lowPrice(175.00) - .closePrice(172.96) - .volume(0) - .add(); - data.barBuilder() - .openPrice(173.00) - .highPrice(173.17) - .lowPrice(172.06) - .closePrice(173.05) - .volume(0) - .add(); - data.barBuilder() - .openPrice(172.26) - .highPrice(172.28) - .lowPrice(170.50) - .closePrice(170.96) - .volume(0) - .add(); - data.barBuilder() - .openPrice(170.88) - .highPrice(172.34) - .lowPrice(170.26) - .closePrice(171.64) - .volume(0) - .add(); - data.barBuilder() - .openPrice(171.85) - .highPrice(172.07) - .lowPrice(169.34) - .closePrice(170.01) - .volume(0) - .add(); - data.barBuilder() - .openPrice(170.75) - .highPrice(172.56) - .lowPrice(170.36) - .closePrice(172.52) - .volume(0) - .add(); // FB, daily, 9.19.'17 + data.barBuilder().openPrice(168.28).highPrice(169.87).lowPrice(167.15).closePrice(169.64).volume(0).add(); + data.barBuilder().openPrice(168.84).highPrice(169.36).lowPrice(168.20).closePrice(168.71).volume(0).add(); + data.barBuilder().openPrice(168.88).highPrice(169.29).lowPrice(166.41).closePrice(167.74).volume(0).add(); + data.barBuilder().openPrice(168).highPrice(168.38).lowPrice(166.18).closePrice(166.32).volume(0).add(); + data.barBuilder().openPrice(166.89).highPrice(167.70).lowPrice(166.33).closePrice(167.24).volume(0).add(); + data.barBuilder().openPrice(165.25).highPrice(168.43).lowPrice(165.00).closePrice(168.05).volume(0).add(); + data.barBuilder().openPrice(168.17).highPrice(170.18).lowPrice(167.63).closePrice(169.92).volume(0).add(); + data.barBuilder().highPrice(170.42).lowPrice(172.15).closePrice(170.06).lowPrice(171.97).volume(0).add(); + data.barBuilder().openPrice(172.41).highPrice(172.92).lowPrice(171.31).closePrice(172.02).volume(0).add(); + data.barBuilder().openPrice(171.2).highPrice(172.39).lowPrice(169.55).closePrice(170.72).volume(0).add(); + data.barBuilder().openPrice(170.91).highPrice(172.48).lowPrice(169.57).closePrice(172.09).volume(0).add(); + data.barBuilder().openPrice(171.80).highPrice(173.31).lowPrice(170.27).closePrice(173.21).volume(0).add(); + data.barBuilder().openPrice(173.09).highPrice(173.49).lowPrice(170.80).closePrice(170.95).volume(0).add(); + data.barBuilder().openPrice(172.41).highPrice(173.89).lowPrice(172.20).closePrice(173.51).volume(0).add(); + data.barBuilder().openPrice(173.87).highPrice(174.17).lowPrice(175.00).closePrice(172.96).volume(0).add(); + data.barBuilder().openPrice(173.00).highPrice(173.17).lowPrice(172.06).closePrice(173.05).volume(0).add(); + data.barBuilder().openPrice(172.26).highPrice(172.28).lowPrice(170.50).closePrice(170.96).volume(0).add(); + data.barBuilder().openPrice(170.88).highPrice(172.34).lowPrice(170.26).closePrice(171.64).volume(0).add(); + data.barBuilder().openPrice(171.85).highPrice(172.07).lowPrice(169.34).closePrice(170.01).volume(0).add(); + data.barBuilder().openPrice(170.75).highPrice(172.56).lowPrice(170.36).closePrice(172.52).volume(0).add(); // FB, + // daily, + // 9.19.'17 } diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java index ac3228d19..a92d611e3 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java @@ -22,7 +22,6 @@ public class MockBarBuilder extends BaseBarConvertibleBuilder { private static long countOfProducedBars; private Duration timePeriod; - public MockBarBuilder(NumFactory numFactory) { super(numFactory); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java index 558bc9407..fb33de0b4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -34,7 +34,8 @@ import org.ta4j.core.num.NumFactory; /** - * Generates BaseBar implementations with mocked time or duration if not set by tester. + * Generates BaseBar implementations with mocked time or duration if not set by + * tester. */ public class MockBarSeriesBuilder extends BaseBarSeriesBuilder { diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java index ed8f50cc5..235010767 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java @@ -74,12 +74,12 @@ public class DecimalNumTest { // override the auto-precision based on length of SUPER_PRECISION_STRING by // passing a precision to valueOf() - private final NumFactory superPrecisionFunc = new DecimalNumFactory(256); + private final NumFactory superPrecisionFunc = DecimalNumFactory.getInstance(256); // auto-set precision based on length of SUPER_PRECISION_STRING (120) - private final NumFactory precisionFunc = new DecimalNumFactory(120); - private final NumFactory precision32Func = new DecimalNumFactory(32); + private final NumFactory precisionFunc = DecimalNumFactory.getInstance(120); + private final NumFactory precision32Func = DecimalNumFactory.getInstance(32); private final NumFactory doubleFunc = new DoubleNumFactory(); - private final NumFactory lowPrecisionFunc = new DecimalNumFactory(3); + private final NumFactory lowPrecisionFunc = DecimalNumFactory.getInstance(3); private BarSeries superPrecisionSeries; private BarSeries precisionSeries; diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java index 1ae787fe5..64b11c88d 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java @@ -58,10 +58,10 @@ public void testZero() { Num anyNaNNum = NaN; Num anyDecimalNum = DecimalNum.valueOf(3); Num anyDoubleNum = DoubleNum.valueOf(3); - assertNumEquals(NaN, anyNaNNum.zero()); - assertNumEquals(0, numOf(3).zero()); - assertNumEquals(0, anyDecimalNum.zero()); - assertNumEquals(0, anyDoubleNum.zero()); + assertNumEquals(NaN, anyNaNNum.getNumFactory().zero()); + assertNumEquals(0, numOf(3).getNumFactory().zero()); + assertNumEquals(0, anyDecimalNum.getNumFactory().zero()); + assertNumEquals(0, anyDoubleNum.getNumFactory().zero()); } @Test @@ -69,10 +69,10 @@ public void testOne() { Num anyNaNNum = NaN; Num anyDecimalNum = DecimalNum.valueOf(3); Num anyDoubleNum = DoubleNum.valueOf(3); - assertNumEquals(NaN, anyNaNNum.one()); - assertNumEquals(1, numOf(3).one()); - assertNumEquals(1, anyDecimalNum.one()); - assertNumEquals(1, anyDoubleNum.one()); + assertNumEquals(NaN, anyNaNNum.getNumFactory().one()); + assertNumEquals(1, numOf(3).getNumFactory().one()); + assertNumEquals(1, anyDecimalNum.getNumFactory().one()); + assertNumEquals(1, anyDoubleNum.getNumFactory().one()); } @Test @@ -80,10 +80,10 @@ public void testHundred() { Num anyNaNNum = NaN; Num anyDecimalNum = DecimalNum.valueOf(3); Num anyDoubleNum = DoubleNum.valueOf(3); - assertNumEquals(NaN, anyNaNNum.hundred()); - assertNumEquals(100, numOf(3).hundred()); - assertNumEquals(100, anyDecimalNum.hundred()); - assertNumEquals(100, anyDoubleNum.hundred()); + assertNumEquals(NaN, anyNaNNum.getNumFactory().hundred()); + assertNumEquals(100, numOf(3).getNumFactory().hundred()); + assertNumEquals(100, anyDecimalNum.getNumFactory().hundred()); + assertNumEquals(100, anyDoubleNum.getNumFactory().hundred()); } @Test(expected = AssertionError.class) @@ -115,6 +115,10 @@ public void testDecimalNumPrecision() { } } + private Num numOf(String string, int precision) { + return DecimalNumFactory.getInstance(precision).numOf(string); + } + @Test public void testDecimalNumOffset() { String highPrecisionString = "1.928749238479283749238472398472936872364823749823749238749238749283749238472983749238749832749274"; @@ -126,19 +130,17 @@ public void testDecimalNumOffset() { Num highPrecisionNum = DecimalNum.valueOf(highPrecisionString, 128); // use HIGH_PRECISION PrecisionNums for delta because they are so small assertTrue(((DecimalNum) highPrecisionNum).matches(lowerPrecisionNum, - highPrecisionNum.numOf("0.0000000000000001", HIGH_PRECISION))); + highPrecisionNum.getNumFactory().numOf("0.0000000000000001"))); if (num.getClass().equals(DoubleNum.class)) { assertTrue(((DecimalNum) highPrecisionNum).matches(lowerPrecisionNum, - highPrecisionNum.numOf("0.0000000000000001", HIGH_PRECISION))); + highPrecisionNum.getNumFactory().numOf("0.0000000000000001"))); assertFalse(((DecimalNum) highPrecisionNum).matches(lowerPrecisionNum, - highPrecisionNum.numOf("0.00000000000000001", HIGH_PRECISION))); + highPrecisionNum.getNumFactory().numOf("0.00000000000000001"))); } if (num.getClass().equals(DecimalNum.class)) { // since precisions are the same, will match to any precision - assertTrue(((DecimalNum) highPrecisionNum).matches(lowerPrecisionNum, - highPrecisionNum.numOf( - "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000001", - HIGH_PRECISION))); + assertTrue(((DecimalNum) highPrecisionNum).matches(lowerPrecisionNum, highPrecisionNum.getNumFactory() + .numOf("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000001"))); } } @@ -248,9 +250,9 @@ public void testArithmetic() { assertNumEquals(hundredMillion.dividedBy(hundred), million); assertNumEquals(0, hundredMillion.remainder(hundred)); - Num five = ten.numOf(5); // generate new value with NumFunction - Num zeroDotTwo = ten.numOf(0.2); // generate new value with NumFunction - Num fiveHundred54 = ten.numOf(554); // generate new value with NumFunction + Num five = ten.getNumFactory().numOf(5); // generate new value with NumFunction + Num zeroDotTwo = ten.getNumFactory().numOf(0.2); // generate new value with NumFunction + Num fiveHundred54 = ten.getNumFactory().numOf(554); // generate new value with NumFunction assertNumEquals(0, hundredMillion.remainder(five)); assertNumEquals(0.00032, zeroDotTwo.pow(5)); @@ -259,20 +261,20 @@ public void testArithmetic() { assertNumEquals(554, fiveHundred54.max(five)); assertNumEquals(5, fiveHundred54.min(five)); assertTrue(fiveHundred54.isGreaterThan(five)); - assertFalse(five.isGreaterThan(five.function().apply(5))); + assertFalse(five.isGreaterThan(five.getNumFactory().numOf(5))); assertFalse(five.isGreaterThanOrEqual(fiveHundred54)); - assertFalse(five.isGreaterThanOrEqual(five.function().apply(6))); - assertTrue(five.isGreaterThanOrEqual(five.function().apply(5))); - - assertTrue(five.equals(five.function().apply(5))); - assertTrue(five.equals(five.function().apply(5.0))); - assertTrue(five.equals(five.function().apply((float) 5))); - assertTrue(five.equals(five.function().apply((short) 5))); - - assertFalse(five.equals(five.function().apply(4.9))); - assertFalse(five.equals(five.function().apply(6))); - assertFalse(five.equals(five.function().apply((float) 15))); - assertFalse(five.equals(five.function().apply((short) 45))); + assertFalse(five.isGreaterThanOrEqual(five.getNumFactory().numOf(6))); + assertTrue(five.isGreaterThanOrEqual(five.getNumFactory().numOf(5))); + + assertTrue(five.equals(five.getNumFactory().numOf(5))); + assertTrue(five.equals(five.getNumFactory().numOf(5.0))); + assertTrue(five.equals(five.getNumFactory().numOf((float) 5))); + assertTrue(five.equals(five.getNumFactory().numOf((short) 5))); + + assertFalse(five.equals(five.getNumFactory().numOf(4.9))); + assertFalse(five.equals(five.getNumFactory().numOf(6))); + assertFalse(five.equals(five.getNumFactory().numOf((float) 15))); + assertFalse(five.equals(five.getNumFactory().numOf((short) 45))); } @Test @@ -309,23 +311,11 @@ public void sqrtOfZero() { public void sqrtLudicrousPrecision() { BigDecimal numBD = BigDecimal.valueOf(Double.MAX_VALUE) .multiply(BigDecimal.valueOf(Double.MAX_VALUE).add(BigDecimal.ONE)); - Num sqrt = numOf(numBD).sqrt(100000); if (numOf(0).getClass().equals(DoubleNum.class)) { + Num sqrt = new DoubleNumFactory().numOf(numBD).sqrt(100000); assertEquals("Infinity", sqrt.toString()); - /* - * BigDecimalNum has been replaced by PrecisionNum - * - * } else if (numOf(0).getClass().equals(BigDecimalNum.class)) { - * assertNumEquals("1.7976931348623157000000000000000E+308", sqrt); - * assertNumNotEquals("1.7976931348623157000000000000001E+308", sqrt); - * assertNumEquals(Double.MAX_VALUE, sqrt); - * assertNumEquals(numOf(Double.MAX_VALUE), sqrt); BigDecimal sqrtBD = new - * BigDecimal(sqrt.toString()); assertNumEquals(numOf(numBD), - * numOf(sqrtBD.multiply(sqrtBD, new MathContext(99999, - * RoundingMode.HALF_UP)))); assertNumEquals(numOf(numBD), - * sqrt.multipliedBy(sqrt)); - */ } else if (numOf(0).getClass().equals(DecimalNum.class)) { + Num sqrt = DecimalNumFactory.getInstance(100000).numOf(numBD).sqrt(100000); Properties props = new Properties(); try (InputStream is = getClass().getResourceAsStream("numTest.properties")) { props.load(is); diff --git a/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java b/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java index 0f4d77bba..27c9607e6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/rules/OpenedPositionMinimumBarCountRuleTest.java @@ -47,7 +47,7 @@ public void testAtLeastBarCountRuleForZeroShouldThrowException() { @Test public void testAtLeastOneBarRuleForOpenedTrade() { final var rule = new OpenedPositionMinimumBarCountRule(1); - final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + final var series = new MockBarSeriesBuilder().withNumFactory(DecimalNumFactory.getInstance()) .withData(1, 2, 3, 4) .build(); final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); @@ -61,7 +61,7 @@ public void testAtLeastOneBarRuleForOpenedTrade() { @Test public void testAtLeastMoreThanOneBarRuleForOpenedTrade() { final var rule = new OpenedPositionMinimumBarCountRule(2); - final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + final var series = new MockBarSeriesBuilder().withNumFactory(DecimalNumFactory.getInstance()) .withData(1, 2, 3, 4) .build(); final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series)); @@ -75,7 +75,7 @@ public void testAtLeastMoreThanOneBarRuleForOpenedTrade() { @Test public void testAtLeastBarCountRuleForClosedTradeShouldAlwaysReturnsFalse() { final var rule = new OpenedPositionMinimumBarCountRule(1); - final var series = new MockBarSeriesBuilder().withNumFactory(new DecimalNumFactory()) + final var series = new MockBarSeriesBuilder().withNumFactory(DecimalNumFactory.getInstance()) .withData(1, 2, 3, 4) .build(); final var tradingRecord = new BaseTradingRecord(Trade.buyAt(0, series), Trade.sellAt(1, series)); diff --git a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java index d7eab5f2b..15111eb63 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java @@ -282,21 +282,46 @@ public void findMissingBarsTest() { @Test public void convertBarSeriesTest() { - final BarSeries decimalBarSeries = new MockBarSeriesBuilder() - .withMaxBarCount(100) - .withNumFactory(new DecimalNumFactory()) + final BarSeries decimalBarSeries = new MockBarSeriesBuilder().withMaxBarCount(100) + .withNumFactory(DecimalNumFactory.getInstance()) .withName("useDecimalNum") .build(); - decimalBarSeries.barBuilder().openPrice(1d).closePrice(2d).highPrice(4d).lowPrice(5d).volume(0d).amount(0).trades(7).add(); - decimalBarSeries.barBuilder().openPrice(1d).closePrice(1d).highPrice(1d).lowPrice(1d).volume(1d).amount(0).trades(1).add(); - decimalBarSeries.barBuilder().openPrice(2d).closePrice(2d).highPrice(2d).lowPrice(2d).volume(2d).amount(0).trades(2).add(); + decimalBarSeries.barBuilder() + .openPrice(1d) + .closePrice(2d) + .highPrice(4d) + .lowPrice(5d) + .volume(0d) + .amount(0) + .trades(7) + .add(); + decimalBarSeries.barBuilder() + .openPrice(1d) + .closePrice(1d) + .highPrice(1d) + .lowPrice(1d) + .volume(1d) + .amount(0) + .trades(1) + .add(); + decimalBarSeries.barBuilder() + .openPrice(2d) + .closePrice(2d) + .highPrice(2d) + .lowPrice(2d) + .volume(2d) + .amount(0) + .trades(2) + .add(); // convert barSeries with DecimalNum to barSeries with DoubleNum - final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, new DoubleNumFactory()); + final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, + new DoubleNumFactory()); // convert barSeries with DoubleNum to barSeries with DecimalNum - final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, new DecimalNumFactory()); + final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, + DecimalNumFactory.getInstance()); assertEquals(DecimalNum.class, decimalBarSeries.getFirstBar().getClosePrice().getClass()); assertEquals(DoubleNum.class, decimalToDoubleSeries.getFirstBar().getClosePrice().getClass()); From 64e8618cb51af7a5eb440bff6c687517348f8fde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 18:36:38 +0200 Subject: [PATCH 09/15] Unified num factory creation --- .../src/main/java/org/ta4j/core/num/DoubleNumFactory.java | 4 ++++ ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java | 6 +++--- ta4j-core/src/test/java/org/ta4j/core/PositionTest.java | 8 ++++++-- .../src/test/java/org/ta4j/core/SeriesBuilderTest.java | 4 ++-- ta4j-core/src/test/java/org/ta4j/core/TradeTest.java | 2 +- .../src/test/java/org/ta4j/core/analysis/ReturnsTest.java | 2 +- .../org/ta4j/core/criteria/AbstractCriterionTest.java | 2 +- .../core/criteria/ExpectedShortfallCriterionTest.java | 2 +- .../org/ta4j/core/criteria/ValueAtRiskCriterionTest.java | 2 +- .../org/ta4j/core/indicators/AbstractIndicatorTest.java | 2 +- .../indicators/supertrend/SuperTrendIndicatorTest.java | 2 +- .../supertrend/SuperTrendLowerBandIndicatorTest.java | 2 +- .../supertrend/SuperTrendUpperBandIndicatorTest.java | 2 +- .../src/test/java/org/ta4j/core/num/DecimalNumTest.java | 2 +- ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java | 2 +- .../test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java | 2 +- 16 files changed, 27 insertions(+), 19 deletions(-) diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java index 3edf7d5fc..a85126b9c 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java @@ -27,6 +27,10 @@ public class DoubleNumFactory implements NumFactory { private static final DoubleNumFactory DOUBLE_NUM_FACTORY = new DoubleNumFactory(); + private DoubleNumFactory() { + // hidden + } + @Override public Num minusOne() { return DoubleNum.MINUS_ONE; diff --git a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java index 4144db237..ae2b65169 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/BarSeriesTest.java @@ -398,10 +398,10 @@ public void addTradeTest() { @Test(expected = IllegalArgumentException.class) public void wrongBarTypeDoubleTest() { - var series = new BaseBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).build(); + var series = new BaseBarSeriesBuilder().withNumFactory(DoubleNumFactory.getInstance()).build(); series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)) .endTime(ZonedDateTime.now()) - .closePrice(DecimalNumFactory.getInstance().numOf(1)) + .closePrice(DecimalNumFactory.getInstance().one()) .build()); } @@ -410,7 +410,7 @@ public void wrongBarTypeBigDecimalTest() { var series = new BaseBarSeriesBuilder().withNumFactory(DecimalNumFactory.getInstance()).build(); series.addBar(new BaseBarBuilder().timePeriod(Duration.ofDays(1)) .endTime(ZonedDateTime.now()) - .closePrice(new DoubleNumFactory().numOf(1)) + .closePrice(DoubleNumFactory.getInstance().one()) .build()); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java b/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java index 1c8fd6884..b9d8c4573 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/PositionTest.java @@ -244,14 +244,18 @@ public void testGetGrossReturnForShortPositions() { @Test public void testGetGrossReturnForLongPositionsUsingBarCloseOnNaN() { - var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).withData(100, 105).build(); + var series = new MockBarSeriesBuilder().withNumFactory(DoubleNumFactory.getInstance()) + .withData(100, 105) + .build(); Position position = new Position(new Trade(0, TradeType.BUY, NaN, NaN), new Trade(1, TradeType.SELL, NaN, NaN)); assertNumEquals(DoubleNum.valueOf(1.05), position.getGrossReturn(series)); } @Test public void testGetGrossReturnForShortPositionsUsingBarCloseOnNaN() { - var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()).withData(100, 95).build(); + var series = new MockBarSeriesBuilder().withNumFactory(DoubleNumFactory.getInstance()) + .withData(100, 95) + .build(); Position position = new Position(new Trade(0, TradeType.SELL, NaN, NaN), new Trade(1, TradeType.BUY, NaN, NaN)); assertNumEquals(DoubleNum.valueOf(1.05), position.getGrossReturn(series)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java index c77af20fd..41ad82770 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/SeriesBuilderTest.java @@ -46,7 +46,7 @@ public void testBuilder() { BarSeries defaultSeriesName = seriesBuilder.withName("default").build(); // build a new empty bar series using // BigDecimal as delegate BarSeries doubleSeries = seriesBuilder.withMaxBarCount(100) - .withNumFactory(new DoubleNumFactory()) + .withNumFactory(DoubleNumFactory.getInstance()) .withName("useDoubleNum") .build(); BarSeries precisionSeries = seriesBuilder.withMaxBarCount(100) @@ -102,7 +102,7 @@ public void testBuilder() { @Test public void testNumFunctions() { - BarSeries series = seriesBuilder.withNumFactory(new DoubleNumFactory()).build(); + BarSeries series = seriesBuilder.withNumFactory(DoubleNumFactory.getInstance()).build(); assertNumEquals(series.numFactory().numOf(12), DoubleNum.valueOf(12)); } diff --git a/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java b/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java index 39939caa0..efef0d915 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/TradeTest.java @@ -88,7 +88,7 @@ public void initializeWithCostsTest() { @Test public void testReturnBarSeriesCloseOnNaN() { - var series = new MockBarSeriesBuilder().withNumFactory(new DoubleNumFactory()) + var series = new MockBarSeriesBuilder().withNumFactory(DoubleNumFactory.getInstance()) .withData(100, 95, 100, 80, 85, 130) .build(); Trade trade = new Trade(1, TradeType.BUY, NaN); diff --git a/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java b/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java index b6036cef3..70be03ab2 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/analysis/ReturnsTest.java @@ -42,7 +42,7 @@ public class ReturnsTest { - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); @Test public void returnSize() { diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java index aec528e2c..a506a2072 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/AbstractCriterionTest.java @@ -54,7 +54,7 @@ public AbstractCriterionTest(CriterionFactory factory, NumFactory numFactory) { @Parameterized.Parameters(name = "Test Case: {index} (0=DoubleNum, 1=DecimalNum)") public static List function() { - return List.of(new DoubleNumFactory(), DecimalNumFactory.getInstance()); + return List.of(DoubleNumFactory.getInstance(), DecimalNumFactory.getInstance()); } /** diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java index 83eac91d0..d49453f84 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ExpectedShortfallCriterionTest.java @@ -46,7 +46,7 @@ public class ExpectedShortfallCriterionTest { private BarSeries series; - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); private ExpectedShortfallCriterion getCriterion() { return new ExpectedShortfallCriterion(0.95); diff --git a/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java b/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java index 1f76236d0..854d38ac7 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/criteria/ValueAtRiskCriterionTest.java @@ -41,7 +41,7 @@ public class ValueAtRiskCriterionTest { private BarSeries series; - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); private AnalysisCriterion getCriterion() { return new ValueAtRiskCriterion(0.95); diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java index 535a13439..a500a50cb 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/AbstractIndicatorTest.java @@ -56,7 +56,7 @@ public abstract class AbstractIndicatorTest { @Parameterized.Parameters(name = "Test Case: {index} (0=DoubleNum, 1=DecimalNum)") public static List function() { - return List.of(new DoubleNumFactory(), DecimalNumFactory.getInstance()); + return List.of(DoubleNumFactory.getInstance(), DecimalNumFactory.getInstance()); } private final IndicatorFactory factory; diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java index f07060be8..9656ae7b9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendIndicatorTest.java @@ -35,7 +35,7 @@ public class SuperTrendIndicatorTest { private BarSeries data; - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); @Before public void setUp() { diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java index d7f693bdf..25c0879c1 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendLowerBandIndicatorTest.java @@ -35,7 +35,7 @@ public class SuperTrendLowerBandIndicatorTest { private BarSeries data; - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); @Before public void setUp() { diff --git a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java index 9a983d8b7..11951634e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/indicators/supertrend/SuperTrendUpperBandIndicatorTest.java @@ -36,7 +36,7 @@ public class SuperTrendUpperBandIndicatorTest { private BarSeries data; - private NumFactory numFactory = new DoubleNumFactory(); + private NumFactory numFactory = DoubleNumFactory.getInstance(); @Before public void setUp() { diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java index 235010767..e54e9f83e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/DecimalNumTest.java @@ -78,7 +78,7 @@ public class DecimalNumTest { // auto-set precision based on length of SUPER_PRECISION_STRING (120) private final NumFactory precisionFunc = DecimalNumFactory.getInstance(120); private final NumFactory precision32Func = DecimalNumFactory.getInstance(32); - private final NumFactory doubleFunc = new DoubleNumFactory(); + private final NumFactory doubleFunc = DoubleNumFactory.getInstance(); private final NumFactory lowPrecisionFunc = DecimalNumFactory.getInstance(3); private BarSeries superPrecisionSeries; diff --git a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java index 64b11c88d..4557387e4 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/num/NumTest.java @@ -312,7 +312,7 @@ public void sqrtLudicrousPrecision() { BigDecimal numBD = BigDecimal.valueOf(Double.MAX_VALUE) .multiply(BigDecimal.valueOf(Double.MAX_VALUE).add(BigDecimal.ONE)); if (numOf(0).getClass().equals(DoubleNum.class)) { - Num sqrt = new DoubleNumFactory().numOf(numBD).sqrt(100000); + Num sqrt = DoubleNumFactory.getInstance().numOf(numBD).sqrt(100000); assertEquals("Infinity", sqrt.toString()); } else if (numOf(0).getClass().equals(DecimalNum.class)) { Num sqrt = DecimalNumFactory.getInstance(100000).numOf(numBD).sqrt(100000); diff --git a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java index 15111eb63..a177a5ee8 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java +++ b/ta4j-core/src/test/java/org/ta4j/core/utils/BarSeriesUtilsTest.java @@ -317,7 +317,7 @@ public void convertBarSeriesTest() { // convert barSeries with DecimalNum to barSeries with DoubleNum final BarSeries decimalToDoubleSeries = BarSeriesUtils.convertBarSeries(decimalBarSeries, - new DoubleNumFactory()); + DoubleNumFactory.getInstance()); // convert barSeries with DoubleNum to barSeries with DecimalNum final BarSeries doubleToDecimalSeries = BarSeriesUtils.convertBarSeries(decimalToDoubleSeries, From d40703e8e2ce690b74e2cf079fa33c3a169de6fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 18:37:09 +0200 Subject: [PATCH 10/15] Updated version to 1.0-SNAPSHOT --- ta4j-examples/pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ta4j-examples/pom.xml b/ta4j-examples/pom.xml index 94527db9e..94685e364 100644 --- a/ta4j-examples/pom.xml +++ b/ta4j-examples/pom.xml @@ -23,7 +23,7 @@ org.ta4j ta4j-core - 0.16 + ${project.version} @@ -50,4 +50,4 @@ - \ No newline at end of file + From 46f1b3d05f89eaee4d6ec6fde83cb777fe915381 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Thu, 11 Apr 2024 18:37:21 +0200 Subject: [PATCH 11/15] Fixed examples --- .../barSeries/BuildBarSeries.java | 19 ++++++++++--- .../bots/TradingBotOnMovingBarSeries.java | 15 ++++++++--- .../ta4jexamples/loaders/CsvBarsLoader.java | 7 +++-- .../ta4jexamples/loaders/CsvTradesLoader.java | 2 +- .../loaders/jsonhelper/GsonBarData.java | 6 +++-- .../ta4jexamples/num/CompareNumTypes.java | 27 +++++++++---------- .../strategies/UnstableIndicatorStrategy.java | 16 ++++++----- 7 files changed, 59 insertions(+), 33 deletions(-) diff --git a/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java b/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java index 4d3b52f80..de3a76127 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java +++ b/ta4j-examples/src/main/java/ta4jexamples/barSeries/BuildBarSeries.java @@ -69,6 +69,7 @@ private static BarSeries buildAndAddData() { private static void addBars(final BarSeries series, final ZonedDateTime endTime) { series.addBar(series.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(endTime) .openPrice(105.42) .highPrice(112.99) @@ -77,6 +78,7 @@ private static void addBars(final BarSeries series, final ZonedDateTime endTime) .volume(1337) .build()); series.addBar(series.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(endTime.plusDays(1)) .openPrice(111.43) .highPrice(112.83) @@ -85,6 +87,7 @@ private static void addBars(final BarSeries series, final ZonedDateTime endTime) .volume(1234) .build()); series.addBar(series.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(endTime.plusDays(2)) .openPrice(107.90) .highPrice(117.50) @@ -95,7 +98,9 @@ private static void addBars(final BarSeries series, final ZonedDateTime endTime) } private static BarSeries buildWithDouble() { - var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries") + .withNumFactory(DoubleNumFactory.getInstance()) + .build(); var endTime = ZonedDateTime.now(); addBars(series, endTime); @@ -104,7 +109,9 @@ private static BarSeries buildWithDouble() { } private static BarSeries buildWithBigDecimal() { - var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DecimalNumFactory()).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries") + .withNumFactory(DecimalNumFactory.getInstance()) + .build(); ZonedDateTime endTime = ZonedDateTime.now(); addBars(series, endTime); @@ -124,7 +131,9 @@ private static BarSeries buildManually() { } private static BarSeries buildManuallyDoubleNum() { - var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries") + .withNumFactory(DoubleNumFactory.getInstance()) + .build(); ZonedDateTime endTime = ZonedDateTime.now(); addBars(series, endTime); // ... @@ -133,7 +142,9 @@ private static BarSeries buildManuallyDoubleNum() { } private static BarSeries buildManuallyAndAddBarManually() { - var series = new BaseBarSeriesBuilder().withName("mySeries").withNumFactory(new DoubleNumFactory()).build(); + var series = new BaseBarSeriesBuilder().withName("mySeries") + .withNumFactory(DoubleNumFactory.getInstance()) + .build(); // create bars and add them to the series. The bars have the same Num type // as the series diff --git a/ta4j-examples/src/main/java/ta4jexamples/bots/TradingBotOnMovingBarSeries.java b/ta4j-examples/src/main/java/ta4jexamples/bots/TradingBotOnMovingBarSeries.java index 935a82eca..cd6c80ff0 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/bots/TradingBotOnMovingBarSeries.java +++ b/ta4j-examples/src/main/java/ta4jexamples/bots/TradingBotOnMovingBarSeries.java @@ -28,7 +28,7 @@ import org.ta4j.core.Bar; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; +import org.ta4j.core.BaseBarConvertibleBuilder; import org.ta4j.core.BaseStrategy; import org.ta4j.core.BaseTradingRecord; import org.ta4j.core.Strategy; @@ -37,10 +37,10 @@ import org.ta4j.core.indicators.SMAIndicator; import org.ta4j.core.indicators.helpers.ClosePriceIndicator; import org.ta4j.core.num.DecimalNum; +import org.ta4j.core.num.DecimalNumFactory; import org.ta4j.core.num.Num; import org.ta4j.core.rules.OverIndicatorRule; import org.ta4j.core.rules.UnderIndicatorRule; - import ta4jexamples.loaders.CsvTradesLoader; /** @@ -119,8 +119,15 @@ private static Bar generateRandomBar() { Num highPrice = openPrice.plus(maxRange.multipliedBy(DecimalNum.valueOf(Math.random()))); Num closePrice = randDecimal(lowPrice, highPrice); LAST_BAR_CLOSE_PRICE = closePrice; - return new BaseBar(Duration.ofDays(1), ZonedDateTime.now(), openPrice, highPrice, lowPrice, closePrice, - DecimalNum.valueOf(1), DecimalNum.valueOf(1)); + return new BaseBarConvertibleBuilder(DecimalNumFactory.getInstance()).amount(1) + .volume(1) + .timePeriod(Duration.ofDays(1)) + .endTime(ZonedDateTime.now()) + .openPrice(openPrice) + .highPrice(highPrice) + .lowPrice(lowPrice) + .closePrice(closePrice) + .build(); } public static void main(String[] args) throws InterruptedException { diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java index 49cd371fd..92b645298 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvBarsLoader.java @@ -26,6 +26,7 @@ import java.io.IOException; import java.io.InputStreamReader; import java.nio.charset.StandardCharsets; +import java.time.Duration; import java.time.LocalDate; import java.time.ZoneId; import java.time.ZonedDateTime; @@ -79,14 +80,16 @@ public static BarSeries loadCsvSeries(String filename) { double close = Double.parseDouble(line[4]); double volume = Double.parseDouble(line[5]); - series.addBar(series.barBuilder() + series.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(date) .openPrice(open) .closePrice(close) .highPrice(high) .lowPrice(low) .volume(volume) - .build()); + .amount(0) + .add(); } } catch (CsvValidationException e) { Logger.getLogger(CsvBarsLoader.class.getName()) diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java index 782e46159..b728309b4 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/CsvTradesLoader.java @@ -105,7 +105,7 @@ private static void buildSeries(BarSeries series, ZonedDateTime beginTime, Zoned do { // build a bar barEndTime = barEndTime.plus(barDuration); - var bar = series.barBuilder().timePeriod(barDuration).endTime(barEndTime).build(); + var bar = series.barBuilder().timePeriod(barDuration).endTime(barEndTime).volume(0).amount(0).build(); do { // get a trade String[] tradeLine = iterator.next(); diff --git a/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java b/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java index 6b3f8fd38..092dfd57c 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java +++ b/ta4j-examples/src/main/java/ta4jexamples/loaders/jsonhelper/GsonBarData.java @@ -23,6 +23,7 @@ */ package ta4jexamples.loaders.jsonhelper; +import java.time.Duration; import java.time.Instant; import java.time.ZoneId; import java.time.ZonedDateTime; @@ -54,7 +55,8 @@ public static GsonBarData from(Bar bar) { public void addTo(BaseBarSeries barSeries) { var endTimeInstant = Instant.ofEpochMilli(endTime); var endBarTime = ZonedDateTime.ofInstant(endTimeInstant, ZoneId.systemDefault()); - barSeries.addBar(barSeries.barBuilder() + barSeries.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(endBarTime) .openPrice(openPrice) .highPrice(highPrice) @@ -62,6 +64,6 @@ public void addTo(BaseBarSeries barSeries) { .closePrice(closePrice) .volume(volume) .amount(amount) - .build()); + .add(); } } diff --git a/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java b/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java index 2b5135428..0f31c6378 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java +++ b/ta4j-examples/src/main/java/ta4jexamples/num/CompareNumTypes.java @@ -23,6 +23,7 @@ */ package ta4jexamples.num; +import java.time.Duration; import java.time.ZonedDateTime; import java.util.Random; @@ -55,44 +56,42 @@ public class CompareNumTypes { public static void main(String args[]) { BaseBarSeriesBuilder barSeriesBuilder = new BaseBarSeriesBuilder(); BarSeries seriesD = barSeriesBuilder.withName("Sample Series Double ") - .withNumFactory(new DoubleNumFactory()) + .withNumFactory(DoubleNumFactory.getInstance()) .build(); BarSeries seriesP = barSeriesBuilder.withName("Sample Series DecimalNum 32") - .withNumFactory(new DecimalNumFactory()) + .withNumFactory(DecimalNumFactory.getInstance()) .build(); BarSeries seriesPH = barSeriesBuilder.withName("Sample Series DecimalNum 256") - .withNumFactory(new DecimalNumFactory() { - @Override - public Num numOf(final Number number) { - return DecimalNum.valueOf(number.toString(), 256); - } - }) + .withNumFactory(DecimalNumFactory.getInstance(256)) .build(); int[] randoms = new Random().ints(NUMBARS, 80, 100).toArray(); for (int i = 0; i < randoms.length; i++) { ZonedDateTime date = ZonedDateTime.now().minusSeconds(NUMBARS - i); - seriesD.addBar(seriesD.barBuilder() + seriesD.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(date) .openPrice(randoms[i]) .closePrice(randoms[i] + 21) .highPrice(randoms[i] - 21) .lowPrice(randoms[i] - 5) - .build()); - seriesP.addBar(seriesP.barBuilder() + .add(); + seriesP.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(date) .openPrice(randoms[i]) .closePrice(randoms[i] + 21) .highPrice(randoms[i] - 21) .lowPrice(randoms[i] - 5) - .build()); - seriesPH.addBar(seriesPH.barBuilder() + .add(); + seriesPH.barBuilder() + .timePeriod(Duration.ofDays(1)) .endTime(date) .openPrice(randoms[i]) .closePrice(randoms[i] + 21) .highPrice(randoms[i] - 21) .lowPrice(randoms[i] - 5) - .build()); + .add(); } Num D = DecimalNum.valueOf(test(seriesD).toString(), 256); Num P = DecimalNum.valueOf(test(seriesP).toString(), 256); diff --git a/ta4j-examples/src/main/java/ta4jexamples/strategies/UnstableIndicatorStrategy.java b/ta4j-examples/src/main/java/ta4jexamples/strategies/UnstableIndicatorStrategy.java index 34d65c72d..c5a49c4af 100644 --- a/ta4j-examples/src/main/java/ta4jexamples/strategies/UnstableIndicatorStrategy.java +++ b/ta4j-examples/src/main/java/ta4jexamples/strategies/UnstableIndicatorStrategy.java @@ -26,11 +26,9 @@ import java.time.Duration; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.ta4j.core.BarSeries; -import org.ta4j.core.BaseBar; import org.ta4j.core.BaseBarSeriesBuilder; import org.ta4j.core.BaseStrategy; import org.ta4j.core.Indicator; @@ -80,10 +78,16 @@ public static void appropriateTrade() { public static void test(String name, Stream closePrices) { // Getting the bar series - BarSeries series = new BaseBarSeriesBuilder() - .withBars(closePrices.map(close -> new BaseBar(MINUTE, TIME, 0, 0, 0, close, 0)) - .collect(Collectors.toList())) - .build(); + BarSeries series = new BaseBarSeriesBuilder().build(); + + closePrices.forEach(close -> series.barBuilder() + .timePeriod(MINUTE) + .endTime(TIME) + .openPrice(0) + .closePrice(close) + .highPrice(0) + .lowPrice(0) + .add()); // Building the trading strategy Strategy strategy = buildStrategy(series); From a8400f34fdc534919680b28b500a78ec059e08b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Fri, 10 May 2024 06:36:21 +0200 Subject: [PATCH 12/15] Updated license headers --- .../org/ta4j/core/BaseBarBuilderFactory.java | 26 ++++++++++++++++--- .../ta4j/core/BaseBarConvertibleBuilder.java | 23 ++++++++++++++++ .../java/org/ta4j/core/num/NumFactory.java | 2 +- .../org/ta4j/core/mocks/MockBarBuilder.java | 23 ++++++++++++++++ .../core/mocks/MockBarBuilderFactory.java | 23 ++++++++++++++++ .../ta4j/core/mocks/MockBarSeriesBuilder.java | 2 +- 6 files changed, 94 insertions(+), 5 deletions(-) diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java index c2445db1d..b25a8dfd6 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java @@ -1,8 +1,28 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core; -/** - * @author Lukáš Kvídera - */ class BaseBarBuilderFactory implements BarBuilderFactory { @Override diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java index 55c2347d8..94d6452de 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java @@ -1,3 +1,26 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core; import java.time.Duration; diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java index 5becf96fe..40fa7c28d 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java @@ -1,4 +1,4 @@ -/** +/* * The MIT License (MIT) * * Copyright (c) 2017-2024 Ta4j Organization & respective diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java index a92d611e3..578f9958e 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java @@ -1,3 +1,26 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core.mocks; import java.time.Clock; diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java index 815337dce..fe2c696b6 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java @@ -1,3 +1,26 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2017-2024 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core.mocks; import org.ta4j.core.BarBuilderFactory; diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java index fb33de0b4..cfeda6e16 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -1,4 +1,4 @@ -/** +/* * The MIT License (MIT) * * Copyright (c) 2017-2024 Ta4j Organization & respective From 10cc2a513442c73f2bc4d55b5950d2c5e8e9faa1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Sun, 19 May 2024 13:19:12 +0200 Subject: [PATCH 13/15] Added changelog for NumFactory --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 335b1498d..641a00da9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,7 @@ Changelog for `ta4j`, roughly following [keepachangelog.com](http://keepachangelog.com/en/1.0.0/) from version 0.9 onwards. ## 0.17 - +- Extracted NumFactory as source of numbers with defined precision ## 0.16 (released May 15, 2024) From 0f180c60cb8c25e76ad833a7ed985e459150b2ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Wed, 3 Jul 2024 21:25:16 +0200 Subject: [PATCH 14/15] Regenerated license headers from template --- .../org/ta4j/core/BaseBarBuilderFactory.java | 4 +- .../ta4j/core/BaseBarConvertibleBuilder.java | 4 +- .../org/ta4j/core/num/DecimalNumFactory.java | 44 +++++++++---------- .../org/ta4j/core/num/DoubleNumFactory.java | 44 +++++++++---------- .../java/org/ta4j/core/num/NumFactory.java | 4 +- .../org/ta4j/core/mocks/MockBarBuilder.java | 4 +- .../core/mocks/MockBarBuilderFactory.java | 4 +- .../ta4j/core/mocks/MockBarSeriesBuilder.java | 4 +- 8 files changed, 56 insertions(+), 56 deletions(-) diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java index b25a8dfd6..d8bea1828 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarBuilderFactory.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of diff --git a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java index 94d6452de..9e577069e 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java +++ b/ta4j-core/src/main/java/org/ta4j/core/BaseBarConvertibleBuilder.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java index e7b036bd9..843f18538 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DecimalNumFactory.java @@ -1,26 +1,26 @@ /** -* The MIT License (MIT) -* -* Copyright (c) 2017-2023 Ta4j Organization & respective -* authors (see AUTHORS) -* -* Permission is hereby granted, free of charge, to any person obtaining a copy of -* this software and associated documentation files (the "Software"), to deal in -* the Software without restriction, including without limitation the rights to -* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -* the Software, and to permit persons to whom the Software is furnished to do so, -* subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in all -* copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ + * The MIT License (MIT) + * + * Copyright (c) 2017-2023 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core.num; import static org.ta4j.core.num.DecimalNum.DEFAULT_PRECISION; diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java index a85126b9c..5051ebc03 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/DoubleNumFactory.java @@ -1,26 +1,26 @@ /** -* The MIT License (MIT) -* -* Copyright (c) 2017-2023 Ta4j Organization & respective -* authors (see AUTHORS) -* -* Permission is hereby granted, free of charge, to any person obtaining a copy of -* this software and associated documentation files (the "Software"), to deal in -* the Software without restriction, including without limitation the rights to -* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -* the Software, and to permit persons to whom the Software is furnished to do so, -* subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in all -* copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ + * The MIT License (MIT) + * + * Copyright (c) 2017-2023 Ta4j Organization & respective + * authors (see AUTHORS) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ package org.ta4j.core.num; public class DoubleNumFactory implements NumFactory { diff --git a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java index 40fa7c28d..e05c33578 100644 --- a/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java +++ b/ta4j-core/src/main/java/org/ta4j/core/num/NumFactory.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java index 578f9958e..28d1c8cd0 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilder.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java index fe2c696b6..7260ffc36 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarBuilderFactory.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java index cfeda6e16..0de2907a9 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -1,7 +1,7 @@ -/* +/** * The MIT License (MIT) * - * Copyright (c) 2017-2024 Ta4j Organization & respective + * Copyright (c) 2017-2023 Ta4j Organization & respective * authors (see AUTHORS) * * Permission is hereby granted, free of charge, to any person obtaining a copy of From 264517f87b97f199cc1093bbbe79e15470e7b065 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Kv=C3=ADdera?= Date: Sun, 21 Jul 2024 17:47:47 +0200 Subject: [PATCH 15/15] Use minutes instead of seconds --- .../src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java index 0de2907a9..eb2adac6b 100644 --- a/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java +++ b/ta4j-core/src/test/java/org/ta4j/core/mocks/MockBarSeriesBuilder.java @@ -72,7 +72,7 @@ public MockBarSeriesBuilder withData(final double... data) { private static void doublesToBars(final BarSeries series, final List data) { for (int i = 0; i < data.size(); i++) { series.barBuilder() - .endTime(ZonedDateTime.now().minusSeconds((data.size() + 1 - i))) + .endTime(ZonedDateTime.now().minusMinutes((data.size() + 1 - i))) .closePrice(data.get(i)) .openPrice(0) .add();