Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
method2testcases
stringlengths
118
6.63k
### Question: NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(10 + 5, profit.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-5 + -30, profit.calculate(series, tradingRecord)); } @Test public void calculateWithOneWinningAndOneLosingTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 195, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(95 + -30, profit.calculate(series, tradingRecord)); }
### Question: ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(50), numOf(45))); assertFalse(criterion.betterThan(numOf(45), numOf(50))); }
### Question: IsHighestRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { HighestValueIndicator highest = new HighestValueIndicator(ref, barCount); Num highestVal = highest.getValue(index); Num refVal = ref.getValue(index); final boolean satisfied = !refVal.isNaN() && !highestVal.isNaN() && refVal.equals(highestVal); traceIsSatisfied(index, satisfied); return satisfied; } IsHighestRule(Indicator<Num> ref, int barCount); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertTrue(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: TotalLossCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(0, profit.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-35, profit.calculate(series, tradingRecord)); } @Test public void calculateProfitWithTradesThatStartSelling() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-35, profit.calculate(series, tradingRecord)); }
### Question: TotalLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } ValueAtRiskCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(90d / 104)), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(80d / 100)), varCriterion.calculate(series, tradingRecord)); } @Test public void calculateWithNoBarsShouldReturn0() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithBuyAndHold() { series = new MockBarSeries(numFunction, 100d, 99d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, trade)); }
### Question: ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ValueAtRiskCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @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))); }
### Question: InSlopeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { DifferenceIndicator diff = new DifferenceIndicator(ref, prev); Num val = diff.getValue(index); boolean minSlopeSatisfied = minSlope.isNaN() || val.isGreaterThanOrEqual(minSlope); boolean maxSlopeSatisfied = maxSlope.isNaN() || val.isLessThanOrEqual(maxSlope); boolean isNaN = minSlope.isNaN() && maxSlope.isNaN(); final boolean satisfied = minSlopeSatisfied && maxSlopeSatisfied && !isNaN; traceIsSatisfied(index, satisfied); return satisfied; } InSlopeRule(Indicator<Num> ref, Num minSlope); InSlopeRule(Indicator<Num> ref, Num minSlope, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num minSlope, Num maxSlope); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rulePositiveSlope.isSatisfied(0)); assertTrue(rulePositiveSlope.isSatisfied(1)); assertFalse(rulePositiveSlope.isSatisfied(2)); assertFalse(rulePositiveSlope.isSatisfied(9)); assertFalse(ruleNegativeSlope.isSatisfied(0)); assertFalse(ruleNegativeSlope.isSatisfied(1)); assertTrue(ruleNegativeSlope.isSatisfied(5)); assertFalse(ruleNegativeSlope.isSatisfied(9)); }
### Question: NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0, buyAndHold.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(2, buyAndHold.calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(); AnalysisCriterion tradesCriterion = getCriterion(); assertNumEquals(1, tradesCriterion.calculate(series, trade)); }
### Question: NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(1.10 * 1.05, profit.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(0.95 * 0.7, profit.calculate(series, tradingRecord)); } @Test public void calculateProfitWithTradesThatStartSelling() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals((1 / 0.95) * (1 / 0.7), profit.calculate(series, tradingRecord)); } @Test public void calculateWithNoTradesShouldReturn1() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion profit = getCriterion(); assertNumEquals(1d, profit.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithOpenedTradeShouldReturn1() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion profit = getCriterion(); Trade trade = new Trade(); assertNumEquals(1d, profit.calculate(series, trade)); trade.operate(0); assertNumEquals(1d, profit.calculate(series, trade)); }
### Question: TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: OverIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isGreaterThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } OverIndicatorRule(Indicator<Num> indicator, Number threshold); OverIndicatorRule(Indicator<Num> indicator, Num threshold); OverIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); }
### Question: LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, double a, double b); @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = new LinearTransactionCostCriterion(1000, 0.5); assertTrue(criterion.betterThan(numOf(3.1), numOf(4.2))); assertFalse(criterion.betterThan(numOf(2.1), numOf(1.9))); }
### Question: MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithOnlyGains() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); assertNumEquals(0d, mdd.calculate(series, tradingRecord)); } @Test public void calculateShouldWork() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(3, series), Order.sellAt(4, series), Order.buyAt(5, series), Order.sellAt(6, series)); assertNumEquals(.875d, mdd.calculate(series, tradingRecord)); } @Test public void calculateWithNullSeriesSizeShouldReturn0() { MockBarSeries series = new MockBarSeries(numFunction, new double[] {}); 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); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(3, series), Order.sellAt(4, series), Order.sellAt(5, series), Order.buyAt(6, series)); assertNumEquals(3.8d, mdd.calculate(series, tradingRecord)); } @Test public void withSimpleTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 10, 5, 6, 1); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(2, series), Order.sellAt(3, series), Order.buyAt(3, series), Order.sellAt(4, series)); assertNumEquals(.9d, mdd.calculate(series, tradingRecord)); }
### Question: WaitForRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Order lastOrder = tradingRecord.getLastOrder(orderType); if (lastOrder != null) { int currentNumberOfBars = index - lastOrder.getIndex(); satisfied = currentNumberOfBars >= numberOfBars; } } traceIsSatisfied(index, satisfied); return satisfied; } WaitForRule(OrderType orderType, int numberOfBars); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void waitForSinceLastBuyRuleIsSatisfied() { rule = new WaitForRule(Order.OrderType.BUY, 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(10); assertFalse(rule.isSatisfied(10, tradingRecord)); assertFalse(rule.isSatisfied(11, tradingRecord)); assertFalse(rule.isSatisfied(12, tradingRecord)); assertTrue(rule.isSatisfied(13, tradingRecord)); assertTrue(rule.isSatisfied(14, tradingRecord)); tradingRecord.exit(15); assertTrue(rule.isSatisfied(15, tradingRecord)); assertTrue(rule.isSatisfied(16, tradingRecord)); tradingRecord.enter(17); assertFalse(rule.isSatisfied(17, tradingRecord)); assertFalse(rule.isSatisfied(18, tradingRecord)); assertFalse(rule.isSatisfied(19, tradingRecord)); assertTrue(rule.isSatisfied(20, tradingRecord)); } @Test public void waitForSinceLastSellRuleIsSatisfied() { rule = new WaitForRule(Order.OrderType.SELL, 2); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(10); assertFalse(rule.isSatisfied(10, tradingRecord)); assertFalse(rule.isSatisfied(11, tradingRecord)); assertFalse(rule.isSatisfied(12, tradingRecord)); assertFalse(rule.isSatisfied(13, tradingRecord)); tradingRecord.exit(15); assertFalse(rule.isSatisfied(15, tradingRecord)); assertFalse(rule.isSatisfied(16, tradingRecord)); assertTrue(rule.isSatisfied(17, tradingRecord)); tradingRecord.enter(17); assertTrue(rule.isSatisfied(17, tradingRecord)); assertTrue(rule.isSatisfied(18, tradingRecord)); tradingRecord.exit(20); assertFalse(rule.isSatisfied(20, tradingRecord)); assertFalse(rule.isSatisfied(21, tradingRecord)); assertTrue(rule.isSatisfied(22, tradingRecord)); }
### Question: MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(0.9), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.2), numOf(0.4))); }
### Question: ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series, series.numOf(50)), Order.sellAt(2, series, series.numOf(50)), Order.buyAt(3, series, series.numOf(50)), Order.sellAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(500 + 250, profit.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series, series.numOf(50)), Order.sellAt(1, series, series.numOf(50)), Order.buyAt(2, series, series.numOf(50)), Order.sellAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-250 - 1500, profit.calculate(series, tradingRecord)); } @Test public void calculateShortOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series, series.numOf(50)), Order.buyAt(2, series, series.numOf(50)), Order.sellAt(3, series, series.numOf(50)), Order.buyAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-(500 + 250), profit.calculate(series, tradingRecord)); } @Test public void calculateShortOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series, series.numOf(50)), Order.buyAt(1, series, series.numOf(50)), Order.sellAt(2, series, series.numOf(50)), Order.buyAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(250 + 1500, profit.calculate(series, tradingRecord)); }
### Question: ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(5000), numOf(4500))); assertFalse(criterion.betterThan(numOf(4500), numOf(5000))); }
### Question: ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void calculatePerTrade() { ZeroCostModel model = new ZeroCostModel(); int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), model); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), model); Trade trade = new Trade(entry, exit, model, model); Num cost = model.calculate(trade, holdingPeriod); assertNumEquals(cost, DoubleNum.valueOf(0)); } @Test public void calculatePerPrice() { ZeroCostModel model = new ZeroCostModel(); Num cost = model.calculate(DoubleNum.valueOf(100), DoubleNum.valueOf(1)); assertNumEquals(cost, DoubleNum.valueOf(0)); }
### Question: ZeroCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { ZeroCostModel model = new ZeroCostModel(); CostModel modelSame = new ZeroCostModel(); CostModel modelOther = new LinearTransactionCostModel(0.1); boolean equality = model.equals(modelSame); boolean inequality = model.equals(modelOther); assertTrue(equality); assertFalse(inequality); }
### Question: LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); Num calculate(Num price, Num amount); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); boolean equals(CostModel otherModel); }### Answer: @Test public void calculateZeroTest() { Num price = DoubleNum.valueOf(100); Num amount = DoubleNum.valueOf(2); Num cost = borrowingModel.calculate(price, amount); assertNumEquals(DoubleNum.valueOf(0), cost); } @Test public void calculateBuyTrade() { int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1)); Trade trade = new Trade(entry, exit, new ZeroCostModel(), borrowingModel); Num costsFromTrade = trade.getHoldingCost(); Num costsFromModel = borrowingModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(0)); } @Test public void calculateSellTrade() { int holdingPeriod = 2; Order entry = Order.sellAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Order exit = Order.buyAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1)); Trade trade = new Trade(entry, exit, new ZeroCostModel(), borrowingModel); Num costsFromTrade = trade.getHoldingCost(); Num costsFromModel = borrowingModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(2)); } @Test public void calculateOpenSellTrade() { int currentIndex = 4; Trade trade = new Trade(Order.OrderType.SELL, new ZeroCostModel(), borrowingModel); trade.operate(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Num costsFromTrade = trade.getHoldingCost(currentIndex); Num costsFromModel = borrowingModel.calculate(trade, currentIndex); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(4)); }
### Question: LinearBorrowingCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearBorrowingCostModel) otherModel).feePerPeriod == this.feePerPeriod; } return equality; } LinearBorrowingCostModel(double feePerPeriod); Num calculate(Num price, Num amount); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { LinearBorrowingCostModel model = new LinearBorrowingCostModel(0.1); CostModel modelSameClass = new LinearBorrowingCostModel(0.2); CostModel modelSameFee = new LinearBorrowingCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); }
### Question: LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); Num calculate(Trade trade, int currentIndex); Num calculate(Trade trade); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void calculateSingleOrderCost() { Num price = DoubleNum.valueOf(100); Num amount = DoubleNum.valueOf(2); Num cost = transactionModel.calculate(price, amount); assertNumEquals(DoubleNum.valueOf(2), cost); } @Test public void calculateBuyTrade() { int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), transactionModel); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), transactionModel); Trade trade = new Trade(entry, exit, transactionModel, new ZeroCostModel()); Num costFromBuy = entry.getCost(); Num costFromSell = exit.getCost(); Num costsFromModel = transactionModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costFromBuy.plus(costFromSell)); assertNumEquals(costsFromModel, DoubleNum.valueOf(2.1)); assertNumEquals(costFromBuy, DoubleNum.valueOf(1)); } @Test public void calculateSellTrade() { int holdingPeriod = 2; Order entry = Order.sellAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), transactionModel); Order exit = Order.buyAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), transactionModel); Trade trade = new Trade(entry, exit, transactionModel, new ZeroCostModel()); Num costFromBuy = entry.getCost(); Num costFromSell = exit.getCost(); Num costsFromModel = transactionModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costFromBuy.plus(costFromSell)); assertNumEquals(costsFromModel, DoubleNum.valueOf(2.1)); assertNumEquals(costFromBuy, DoubleNum.valueOf(1)); } @Test public void calculateOpenSellTrade() { int currentIndex = 4; Trade trade = new Trade(Order.OrderType.BUY, transactionModel, new ZeroCostModel()); trade.operate(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Num costsFromModel = transactionModel.calculate(trade, currentIndex); assertNumEquals(costsFromModel, DoubleNum.valueOf(1)); }
### Question: LinearTransactionCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearTransactionCostModel) otherModel).feePerTrade == this.feePerTrade; } return equality; } LinearTransactionCostModel(double feePerTrade); Num calculate(Trade trade, int currentIndex); Num calculate(Trade trade); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { LinearTransactionCostModel model = new LinearTransactionCostModel(0.1); CostModel modelSameClass = new LinearTransactionCostModel(0.2); CostModel modelSameFee = new LinearTransactionCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); }
### Question: OrRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) || rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } OrRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertTrue(satisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.or(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.or(unsatisfiedRule).isSatisfied(0)); assertTrue(satisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(unsatisfiedRule).isSatisfied(10)); }
### Question: Trade implements Serializable { public boolean isOpened() { return (entry != null) && (exit == null); } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); }### Answer: @Test public void whenNewShouldNotExit() { assertFalse(newTrade.isOpened()); }
### Question: Trade implements Serializable { public Order operate(int index) { return operate(index, NaN, NaN); } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); }### Answer: @Test(expected = IllegalStateException.class) public void whenExitIndexIsLessThanEntryIndexShouldThrowException() { newTrade.operate(3); newTrade.operate(1); } @Test public void testEqualsForEntryOrders() { Trade trLeft = newTrade; Trade trRightEquals = new Trade(); Trade trRightNotEquals = new Trade(); assertEquals(OrderType.BUY, trRightNotEquals.operate(2).getType()); assertNotEquals(trLeft, trRightNotEquals); assertEquals(OrderType.BUY, trLeft.operate(1).getType()); assertEquals(OrderType.BUY, trRightEquals.operate(1).getType()); assertEquals(trLeft, trRightEquals); assertNotEquals(trLeft, trRightNotEquals); } @Test public void testEqualsForExitOrders() { Trade trLeft = newTrade; Trade trRightEquals = new Trade(); Trade trRightNotEquals = new Trade(); assertEquals(OrderType.BUY, trLeft.operate(1).getType()); assertEquals(OrderType.BUY, trRightEquals.operate(1).getType()); assertEquals(OrderType.BUY, trRightNotEquals.operate(1).getType()); assertEquals(OrderType.SELL, trRightNotEquals.operate(3).getType()); assertNotEquals(trLeft, trRightNotEquals); assertEquals(OrderType.SELL, trLeft.operate(2).getType()); assertEquals(OrderType.SELL, trRightEquals.operate(2).getType()); assertEquals(trLeft, trRightEquals); assertNotEquals(trLeft, trRightNotEquals); }
### Question: Trade implements Serializable { @Override public String toString() { return "Entry: " + entry + " exit: " + exit; } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); }### Answer: @Test public void overrideToString() { assertEquals(trEquals1.toString(), trEquals2.toString()); assertNotEquals(trEquals1.toString(), trNotEquals1.toString()); assertNotEquals(trEquals1.toString(), trNotEquals2.toString()); }
### Question: PrecisionNum implements Num { private PrecisionNum(String val) { delegate = new BigDecimal(val); int precision = Math.max(delegate.precision(), DEFAULT_PRECISION); mathContext = new MathContext(precision, RoundingMode.HALF_UP); } private PrecisionNum(String val); private PrecisionNum(String val, int precision); private PrecisionNum(short val); private PrecisionNum(int val); private PrecisionNum(long val); private PrecisionNum(float val); private PrecisionNum(double val); private PrecisionNum(BigDecimal val, int precision); static PrecisionNum valueOf(String val); static PrecisionNum valueOf(String val, int precision); static PrecisionNum valueOf(short val); static PrecisionNum valueOf(int val); static PrecisionNum valueOf(long val); static PrecisionNum valueOf(float val); static PrecisionNum valueOf(BigDecimal val); static PrecisionNum valueOf(BigDecimal val, int precision); static PrecisionNum valueOf(double val); static PrecisionNum valueOf(PrecisionNum val); static PrecisionNum valueOf(Number val); @Override Function<Number, Num> function(); @Override BigDecimal getDelegate(); MathContext getMathContext(); @Override String getName(); @Override Num plus(Num augend); @Override Num minus(Num subtrahend); @Override Num multipliedBy(Num multiplicand); @Override Num dividedBy(Num divisor); @Override Num remainder(Num divisor); Num floor(); Num ceil(); @Override Num pow(int n); Num sqrt(); @Override Num sqrt(int precision); Num log(); @Override Num abs(); @Override boolean isZero(); @Override boolean isPositive(); @Override boolean isPositiveOrZero(); @Override boolean isNegative(); @Override boolean isNegativeOrZero(); @Override boolean isEqual(Num other); boolean matches(Num other, int precision); boolean matches(Num other, Num delta); @Override boolean isGreaterThan(Num other); @Override boolean isGreaterThanOrEqual(Num other); @Override boolean isLessThan(Num other); @Override boolean isLessThanOrEqual(Num other); @Override int compareTo(Num other); @Override Num min(Num other); @Override Num max(Num other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override Num pow(Num n); }### Answer: @Test public void precisionNumTest() { init(); test(); }
### Question: PrecisionNum implements Num { public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } private PrecisionNum(String val); private PrecisionNum(String val, int precision); private PrecisionNum(short val); private PrecisionNum(int val); private PrecisionNum(long val); private PrecisionNum(float val); private PrecisionNum(double val); private PrecisionNum(BigDecimal val, int precision); static PrecisionNum valueOf(String val); static PrecisionNum valueOf(String val, int precision); static PrecisionNum valueOf(short val); static PrecisionNum valueOf(int val); static PrecisionNum valueOf(long val); static PrecisionNum valueOf(float val); static PrecisionNum valueOf(BigDecimal val); static PrecisionNum valueOf(BigDecimal val, int precision); static PrecisionNum valueOf(double val); static PrecisionNum valueOf(PrecisionNum val); static PrecisionNum valueOf(Number val); @Override Function<Number, Num> function(); @Override BigDecimal getDelegate(); MathContext getMathContext(); @Override String getName(); @Override Num plus(Num augend); @Override Num minus(Num subtrahend); @Override Num multipliedBy(Num multiplicand); @Override Num dividedBy(Num divisor); @Override Num remainder(Num divisor); Num floor(); Num ceil(); @Override Num pow(int n); Num sqrt(); @Override Num sqrt(int precision); Num log(); @Override Num abs(); @Override boolean isZero(); @Override boolean isPositive(); @Override boolean isPositiveOrZero(); @Override boolean isNegative(); @Override boolean isNegativeOrZero(); @Override boolean isEqual(Num other); boolean matches(Num other, int precision); boolean matches(Num other, Num delta); @Override boolean isGreaterThan(Num other); @Override boolean isGreaterThanOrEqual(Num other); @Override boolean isLessThan(Num other); @Override boolean isLessThanOrEqual(Num other); @Override int compareTo(Num other); @Override Num min(Num other); @Override Num max(Num other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override Num pow(Num n); }### Answer: @Test(expected = NumberFormatException.class) public void testValueOfForFloatNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Float.NaN); } @Test(expected = NumberFormatException.class) public void testValueOfForDoubleNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Double.NaN); }
### Question: BaseBarSeriesAggregator implements BarSeriesAggregator { @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } BaseBarSeriesAggregator(BarAggregator barAggregator); @Override BarSeries aggregate(BarSeries series, String aggregatedSeriesName); }### Answer: @Test public void testAggregateWithNewName() { final List<Bar> 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 BaseBarSeries("name", bars); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries, "newName"); assertEquals("newName", aggregated.getName()); assertEquals(2, aggregated.getBarCount()); assertSame(bar0, aggregated.getBar(0)); assertSame(bar2, aggregated.getBar(1)); } @Test public void testAggregateWithTheSameName() { final List<Bar> 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 BaseBarSeries("name", bars); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries); assertEquals("name", aggregated.getName()); assertEquals(2, aggregated.getBarCount()); assertSame(bar0, aggregated.getBar(0)); assertSame(bar2, aggregated.getBar(1)); }
### Question: JustOnceRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (satisfied) { return false; } else if (rule == null) { satisfied = true; traceIsSatisfied(index, true); return true; } this.satisfied = this.rule.isSatisfied(index, tradingRecord); return this.satisfied; } JustOnceRule(Rule rule); JustOnceRule(); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(10)); assertFalse(rule.isSatisfied(11)); assertFalse(rule.isSatisfied(12)); assertFalse(rule.isSatisfied(13)); assertFalse(rule.isSatisfied(14)); } @Test public void isSatisfiedInReverseOrder() { assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); } @Test public void isSatisfiedWithInnerSatisfiedRule() { JustOnceRule rule = new JustOnceRule(new BooleanRule(true)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); } @Test public void isSatisfiedWithInnerNonSatisfiedRule() { JustOnceRule rule = new JustOnceRule(new BooleanRule(false)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); } @Test public void isSatisfiedWithInnerRule() { JustOnceRule rule = new JustOnceRule(new FixedRule(1, 3, 5)); assertFalse(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(1)); }
### Question: StrategyExecutionLogging { public static void main(String[] args) { loadLoggerConfiguration(); BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = CCICorrectionStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); seriesManager.run(strategy); unloadLoggerConfiguration(); } static void main(String[] args); }### Answer: @Test public void test() { StrategyExecutionLogging.main(null); }
### Question: RSI2Strategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { RSI2Strategy.main(null); }
### Question: GlobalExtremaStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { GlobalExtremaStrategy.main(null); }
### Question: CCICorrectionStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { CCICorrectionStrategy.main(null); }
### Question: MovingMomentumStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { MovingMomentumStrategy.main(null); }
### Question: Quickstart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Num firstClosePrice = series.getBar(0).getClosePrice(); System.out.println("First close price: " + firstClosePrice.doubleValue()); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); System.out.println(firstClosePrice.isEqual(closePrice.getValue(0))); SMAIndicator shortSma = new SMAIndicator(closePrice, 5); System.out.println("5-bars-SMA value at the 42nd index: " + shortSma.getValue(42).doubleValue()); SMAIndicator longSma = new SMAIndicator(closePrice, 30); Rule buyingRule = new CrossedUpIndicatorRule(shortSma, longSma) .or(new CrossedDownIndicatorRule(closePrice, 800)); Rule sellingRule = new CrossedDownIndicatorRule(shortSma, longSma) .or(new StopLossRule(closePrice, series.numOf(3))).or(new StopGainRule(closePrice, series.numOf(2))); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(new BaseStrategy(buyingRule, sellingRule)); System.out.println("Number of trades for our strategy: " + tradingRecord.getTradeCount()); AnalysisCriterion profitTradesRatio = new AverageProfitableTradesCriterion(); System.out.println("Profitable trades ratio: " + profitTradesRatio.calculate(series, tradingRecord)); AnalysisCriterion rewardRiskRatio = new RewardRiskRatioCriterion(); System.out.println("Reward-risk ratio: " + rewardRiskRatio.calculate(series, tradingRecord)); AnalysisCriterion vsBuyAndHold = new VersusBuyAndHoldCriterion(new TotalProfitCriterion()); System.out.println("Our profit vs buy-and-hold profit: " + vsBuyAndHold.calculate(series, tradingRecord)); } static void main(String[] args); }### Answer: @Test public void test() { Quickstart.main(null); }
### Question: BuildBarSeries { @SuppressWarnings("unused") public static void main(String[] args) { BarSeries a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BaseBarSeriesBuilder.setDefaultFunction(DoubleNum::valueOf); a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BarSeries b = buildWithDouble(); BarSeries c = buildWithBigDecimal(); BarSeries d = buildManually(); BarSeries e = buildManuallyDoubleNum(); BarSeries f = buildManuallyAndAddBarManually(); BarSeries g = buildAndAddBarsFromList(); } @SuppressWarnings("unused") static void main(String[] args); }### Answer: @Test public void test() { BuildBarSeries.main(null); }
### Question: IsRisingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isGreaterThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsRisingRule(Indicator<Num> ref, int barCount); IsRisingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: WalkForward { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); List<BarSeries> subseries = splitSeries(series, Duration.ofHours(6), Duration.ofDays(7)); Map<Strategy, String> strategies = buildStrategiesMap(series); AnalysisCriterion profitCriterion = new TotalProfitCriterion(); for (BarSeries slice : subseries) { System.out.println("Sub-series: " + slice.getSeriesPeriodDescription()); BarSeriesManager sliceManager = new BarSeriesManager(slice); for (Map.Entry<Strategy, String> entry : strategies.entrySet()) { Strategy strategy = entry.getKey(); String name = entry.getValue(); TradingRecord tradingRecord = sliceManager.run(strategy); Num profit = profitCriterion.calculate(slice, tradingRecord); System.out.println("\tProfit for " + name + ": " + profit); } Strategy bestStrategy = profitCriterion.chooseBest(sliceManager, new ArrayList<Strategy>(strategies.keySet())); System.out.println("\t\t--> Best strategy: " + strategies.get(bestStrategy) + "\n"); } } static List<Integer> getSplitBeginIndexes(BarSeries series, Duration splitDuration); static BarSeries subseries(BarSeries series, int beginIndex, Duration duration); static List<BarSeries> splitSeries(BarSeries series, Duration splitDuration, Duration sliceDuration); static Map<Strategy, String> buildStrategiesMap(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { WalkForward.main(null); }
### Question: CandlestickChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); OHLCDataset ohlcDataset = createOHLCDataset(series); TimeSeriesCollection xyDataset = createAdditionalDataset(series); JFreeChart chart = ChartFactory.createCandlestickChart("Bitstamp BTC price", "Time", "USD", ohlcDataset, true); CandlestickRenderer renderer = new CandlestickRenderer(); renderer.setAutoWidthMethod(CandlestickRenderer.WIDTHMETHOD_SMALLEST); XYPlot plot = chart.getXYPlot(); plot.setRenderer(renderer); int index = 1; plot.setDataset(index, xyDataset); plot.mapDatasetToRangeAxis(index, 0); XYLineAndShapeRenderer renderer2 = new XYLineAndShapeRenderer(true, false); renderer2.setSeriesPaint(index, Color.blue); plot.setRenderer(index, renderer2); plot.setRangeGridlinePaint(Color.lightGray); plot.setBackgroundPaint(Color.white); NumberAxis numberAxis = (NumberAxis) plot.getRangeAxis(); numberAxis.setAutoRangeIncludesZero(false); plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { CandlestickChart.main(null); }
### Question: IndicatorsToChart { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); EMAIndicator avg14 = new EMAIndicator(closePrice, 14); StandardDeviationIndicator sd14 = new StandardDeviationIndicator(closePrice, 14); BollingerBandsMiddleIndicator middleBBand = new BollingerBandsMiddleIndicator(avg14); BollingerBandsLowerIndicator lowBBand = new BollingerBandsLowerIndicator(middleBBand, sd14); BollingerBandsUpperIndicator upBBand = new BollingerBandsUpperIndicator(middleBBand, sd14); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartBarSeries(series, closePrice, "Apple Inc. (AAPL) - NASDAQ GS")); dataset.addSeries(buildChartBarSeries(series, lowBBand, "Low Bollinger Band")); dataset.addSeries(buildChartBarSeries(series, upBBand, "High Bollinger Band")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Apple Inc. 2013 Close Prices", "Date", "Price Per Unit", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("yyyy-MM-dd")); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { IndicatorsToChart.main(null); }
### Question: IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicator(series); SMAIndicator shortSma = new SMAIndicator(closePrice, 8); SMAIndicator longSma = new SMAIndicator(closePrice, 20); EMAIndicator shortEma = new EMAIndicator(closePrice, 8); EMAIndicator longEma = new EMAIndicator(closePrice, 20); PPOIndicator ppo = new PPOIndicator(closePrice, 12, 26); ROCIndicator roc = new ROCIndicator(closePrice, 100); RSIIndicator rsi = new RSIIndicator(closePrice, 14); WilliamsRIndicator williamsR = new WilliamsRIndicator(series, 20); ATRIndicator atr = new ATRIndicator(series, 20); StandardDeviationIndicator sd = new StandardDeviationIndicator(closePrice, 14); StringBuilder sb = new StringBuilder( "timestamp,close,typical,variation,sma8,sma20,ema8,ema20,ppo,roc,rsi,williamsr,atr,sd\n"); final int nbBars = series.getBarCount(); for (int i = 0; i < nbBars; i++) { sb.append(series.getBar(i).getEndTime()).append(',').append(closePrice.getValue(i)).append(',') .append(typicalPrice.getValue(i)).append(',').append(priceVariation.getValue(i)).append(',') .append(shortSma.getValue(i)).append(',').append(longSma.getValue(i)).append(',') .append(shortEma.getValue(i)).append(',').append(longEma.getValue(i)).append(',') .append(ppo.getValue(i)).append(',').append(roc.getValue(i)).append(',').append(rsi.getValue(i)) .append(',').append(williamsR.getValue(i)).append(',').append(atr.getValue(i)).append(',') .append(sd.getValue(i)).append('\n'); } BufferedWriter writer = null; try { writer = new BufferedWriter(new FileWriter(new File("target", "indicators.csv"))); writer.write(sb.toString()); } catch (IOException ioe) { Logger.getLogger(IndicatorsToCsv.class.getName()).log(Level.SEVERE, "Unable to write CSV file", ioe); } finally { try { if (writer != null) { writer.close(); } } catch (IOException ioe) { ioe.printStackTrace(); } } } static void main(String[] args); }### Answer: @Test public void test() { IndicatorsToCsv.main(null); }
### Question: StrategyAnalysis { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); TotalProfitCriterion totalProfit = new TotalProfitCriterion(); System.out.println("Total profit: " + totalProfit.calculate(series, tradingRecord)); System.out.println("Number of bars: " + new NumberOfBarsCriterion().calculate(series, tradingRecord)); System.out .println("Average profit (per bar): " + new AverageProfitCriterion().calculate(series, tradingRecord)); System.out.println("Number of trades: " + new NumberOfTradesCriterion().calculate(series, tradingRecord)); System.out.println( "Profitable trades ratio: " + new AverageProfitableTradesCriterion().calculate(series, tradingRecord)); System.out.println("Maximum drawdown: " + new MaximumDrawdownCriterion().calculate(series, tradingRecord)); System.out.println("Reward-risk ratio: " + new RewardRiskRatioCriterion().calculate(series, tradingRecord)); System.out.println("Total transaction cost (from $1000): " + new LinearTransactionCostCriterion(1000, 0.005).calculate(series, tradingRecord)); System.out.println("Buy-and-hold: " + new BuyAndHoldCriterion().calculate(series, tradingRecord)); System.out.println("Custom strategy profit vs buy-and-hold strategy profit: " + new VersusBuyAndHoldCriterion(totalProfit).calculate(series, tradingRecord)); } static void main(String[] args); }### Answer: @Test public void test() { StrategyAnalysis.main(null); }
### Question: TradeCost { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildShortSellingMomentumStrategy(series); double feePerTrade = 0.0005; double borrowingFee = 0.00001; CostModel transactionCostModel = new LinearTransactionCostModel(feePerTrade); CostModel borrowingCostModel = new LinearBorrowingCostModel(borrowingFee); BarSeriesManager seriesManager = new BarSeriesManager(series, transactionCostModel, borrowingCostModel); Order.OrderType entryOrder = Order.OrderType.SELL; TradingRecord tradingRecord = seriesManager.run(strategy, entryOrder); DecimalFormat df = new DecimalFormat("##.##"); System.out.println("------------ Borrowing Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println( "Borrowing cost for " + df.format(trade.getExit().getIndex() - trade.getEntry().getIndex()) + " periods is: " + df.format(trade.getHoldingCost().doubleValue()))); System.out.println("------------ Transaction Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println("Transaction cost for selling: " + df.format(trade.getEntry().getCost().doubleValue()) + " -- Transaction cost for buying: " + df.format(trade.getExit().getCost().doubleValue()))); } static void main(String[] args); }### Answer: @Test public void test() { TradeCost.main(null); }
### Question: CashFlowToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); CashFlow cashFlow = new CashFlow(series, tradingRecord); TimeSeriesCollection datasetAxis1 = new TimeSeriesCollection(); datasetAxis1.addSeries(buildChartBarSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); TimeSeriesCollection datasetAxis2 = new TimeSeriesCollection(); datasetAxis2.addSeries(buildChartBarSeries(series, cashFlow, "Cash Flow")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", datasetAxis1, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addCashFlowAxis(plot, datasetAxis2); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { CashFlowToChart.main(null); }
### Question: BuyAndSellSignalsToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartTimeSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addBuySellSignals(series, strategy, plot); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { BuyAndSellSignalsToChart.main(null); }
### Question: CompareNumTypes { public static void main(String args[]) { BaseBarSeriesBuilder barSeriesBuilder = new BaseBarSeriesBuilder(); BarSeries seriesD = barSeriesBuilder.withName("Sample Series Double ").withNumTypeOf(DoubleNum::valueOf) .build(); BarSeries seriesP = barSeriesBuilder.withName("Sample Series PrecisionNum 32") .withNumTypeOf(PrecisionNum::valueOf).build(); BarSeries seriesPH = barSeriesBuilder.withName("Sample Series PrecisionNum 256") .withNumTypeOf(number -> PrecisionNum.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); } Num D = PrecisionNum.valueOf(test(seriesD).toString(), 256); Num P = PrecisionNum.valueOf(test(seriesP).toString(), 256); Num standard = PrecisionNum.valueOf(test(seriesPH).toString(), 256); System.out.println(seriesD.getName() + " error: " + D.minus(standard).dividedBy(standard).multipliedBy(PrecisionNum.valueOf(100))); System.out.println(seriesP.getName() + " error: " + P.minus(standard).dividedBy(standard).multipliedBy(PrecisionNum.valueOf(100))); } static void main(String args[]); static Num test(BarSeries series); }### Answer: @Test public void test() { CompareNumTypes.main(null); }
### Question: TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecord(); System.out.println("************************************************************"); for (int i = 0; i < 50; i++) { Thread.sleep(30); Bar newBar = generateRandomBar(); System.out.println("------------------------------------------------------\n" + "Bar " + i + " added, close price = " + newBar.getClosePrice().doubleValue()); series.addBar(newBar); int endIndex = series.getEndIndex(); if (strategy.shouldEnter(endIndex)) { System.out.println("Strategy should ENTER on " + endIndex); boolean entered = tradingRecord.enter(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (entered) { Order entry = tradingRecord.getLastEntry(); System.out.println("Entered on " + entry.getIndex() + " (price=" + entry.getNetPrice().doubleValue() + ", amount=" + entry.getAmount().doubleValue() + ")"); } } else if (strategy.shouldExit(endIndex)) { System.out.println("Strategy should EXIT on " + endIndex); boolean exited = tradingRecord.exit(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (exited) { Order exit = tradingRecord.getLastExit(); System.out.println("Exited on " + exit.getIndex() + " (price=" + exit.getNetPrice().doubleValue() + ", amount=" + exit.getAmount().doubleValue() + ")"); } } } } static void main(String[] args); }### Answer: @Test public void test() throws InterruptedException { TradingBotOnMovingBarSeries.main(null); }
### Question: CsvTradesLoader { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); 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()); } static BarSeries loadBitstampSeries(); static void main(String[] args); }### Answer: @Test public void test() { CsvTradesLoader.main(null); }
### Question: CsvBarsLoader { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tOpen price: " + series.getBar(0).getOpenPrice() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } static BarSeries loadAppleIncSeries(); static BarSeries loadCsvSeries(String filename); static void main(String[] args); }### Answer: @Test public void test() { CsvBarsLoader.main(null); }
### Question: TrailingStopLossRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num currentPrice = priceIndicator.getValue(index); int tradeIndex = currentTrade.getEntry().getIndex(); if (currentTrade.getEntry().isBuy()) { satisfied = isBuySatisfied(currentPrice, index, tradeIndex); } else { satisfied = isSellSatisfied(currentPrice, index, tradeIndex); } } } traceIsSatisfied(index, satisfied); return satisfied; } TrailingStopLossRule(PriceIndicator priceIndicator, Num lossPercentage, int barCount); TrailingStopLossRule(PriceIndicator priceIndicator, Num lossPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Num getCurrentStopLossLimitActivation(); }### Answer: @Test public void isSatisfiedForBuyForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(OrderType.BUY); ClosePriceIndicator closePrice = new ClosePriceIndicator( new MockBarSeries(numFunction, 100, 110, 120, 130, 120, 117.00, 117.00, 130, 116.99)); TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(114), numOf(1)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertTrue(rule.isSatisfied(5, tradingRecord)); assertFalse(rule.isSatisfied(6, tradingRecord)); tradingRecord.exit(7); tradingRecord.enter(7, numOf(128), numOf(1)); assertFalse(rule.isSatisfied(7, tradingRecord)); assertTrue(rule.isSatisfied(8, tradingRecord)); } @Test public void isSatisfiedForSellForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(OrderType.SELL); ClosePriceIndicator closePrice = new ClosePriceIndicator( new MockBarSeries(numFunction, 100, 90, 80, 70, 70, 73, 77.00, 90, 120, 132.01)); TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(84), numOf(1)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); tradingRecord.exit(7); tradingRecord.enter(7, numOf(91), numOf(1)); assertFalse(rule.isSatisfied(7, tradingRecord)); assertTrue(rule.isSatisfied(8, tradingRecord)); }
### Question: XorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) ^ rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } XorRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertTrue(satisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.xor(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.xor(unsatisfiedRule).isSatisfied(0)); assertFalse(satisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertFalse(BooleanRule.TRUE.xor(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.xor(unsatisfiedRule).isSatisfied(10)); }
### Question: IsFallingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isLessThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsFallingRule(Indicator<Num> ref, int barCount); IsFallingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); }
### Question: StopLossRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num entryPrice = currentTrade.getEntry().getNetPrice(); Num currentPrice = closePrice.getValue(index); if (currentTrade.getEntry().isBuy()) { satisfied = isBuyStopSatisfied(entryPrice, currentPrice); } else { satisfied = isSellStopSatisfied(entryPrice, currentPrice); } } } traceIsSatisfied(index, satisfied); return satisfied; } StopLossRule(ClosePriceIndicator closePrice, Number lossPercentage); StopLossRule(ClosePriceIndicator closePrice, Num lossPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfiedWorksForBuy() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.BUY); final Num tradedAmount = numOf(1); StopLossRule rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(114), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertTrue(rule.isSatisfied(4, tradingRecord)); tradingRecord.exit(5); tradingRecord.enter(5, numOf(128), tradedAmount); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); assertTrue(rule.isSatisfied(7, tradingRecord)); } @Test public void isSatisfiedWorksForSell() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.SELL); final Num tradedAmount = numOf(1); StopLossRule rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(1, numOf(108), tradedAmount); assertFalse(rule.isSatisfied(1, tradingRecord)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(3, tradingRecord)); tradingRecord.exit(4); tradingRecord.enter(2, numOf(114), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertTrue(rule.isSatisfied(5, tradingRecord)); }
### Question: StopGainRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num entryPrice = currentTrade.getEntry().getNetPrice(); Num currentPrice = closePrice.getValue(index); if (currentTrade.getEntry().isBuy()) { satisfied = isBuyGainSatisfied(entryPrice, currentPrice); } else { satisfied = isSellGainSatisfied(entryPrice, currentPrice); } } } traceIsSatisfied(index, satisfied); return satisfied; } StopGainRule(ClosePriceIndicator closePrice, Number gainPercentage); StopGainRule(ClosePriceIndicator closePrice, Num gainPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfiedWorksForBuy() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.BUY); final Num tradedAmount = numOf(1); StopGainRule rule = new StopGainRule(closePrice, numOf(30)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(108), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertTrue(rule.isSatisfied(4, tradingRecord)); tradingRecord.exit(5); tradingRecord.enter(5, numOf(118), tradedAmount); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); assertTrue(rule.isSatisfied(7, tradingRecord)); } @Test public void isSatisfiedWorksForSell() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.SELL); final Num tradedAmount = numOf(1); StopGainRule rule = new StopGainRule(closePrice, numOf(10)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(7, numOf(178), tradedAmount); assertFalse(rule.isSatisfied(7, tradingRecord)); assertFalse(rule.isSatisfied(8, tradingRecord)); assertTrue(rule.isSatisfied(9, tradingRecord)); tradingRecord.exit(10); tradingRecord.enter(3, numOf(119), tradedAmount); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(1, tradingRecord)); assertTrue(rule.isSatisfied(10, tradingRecord)); }
### Question: CrossedUpIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedUpIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedUpIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedUpIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Indicator<Num> getLow(); Indicator<Num> getUp(); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
### Question: AroonUpIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } AroonUpIndicator(Indicator<Num> maxValueIndicator, int barCount); AroonUpIndicator(BarSeries series, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 1000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num maxPrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, maxPrice, NaN, NaN, NaN); } AroonUpIndicator 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)); } } }
### Question: UnderIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isLessThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } UnderIndicatorRule(Indicator<Num> indicator, Number threshold); UnderIndicatorRule(Indicator<Num> indicator, Num threshold); UnderIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
### Question: PeriodicalGrowthRateIndicator extends CachedIndicator<Num> { public Num getTotalReturn() { Num totalProduct = one; int completeTimeFrames = (getBarSeries().getBarCount() / barCount); for (int i = 1; i <= completeTimeFrames; i++) { int index = i * barCount; Num currentReturn = getValue(index); if (currentReturn != NaN) { currentReturn = currentReturn.plus(one); totalProduct = totalProduct.multipliedBy(currentReturn); } } return totalProduct.pow(one.dividedBy(numOf(completeTimeFrames))); } PeriodicalGrowthRateIndicator(Indicator<Num> indicator, int barCount); Num getTotalReturn(); }### Answer: @Test public void testGetTotalReturn() { PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); Num result = gri.getTotalReturn(); assertNumEquals(0.9564, result); }
### Question: LowestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } LowestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), lowestValue.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator 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()); } else assertEquals(series.getBar(Math.max(0, i - 1)).getClosePrice().toString(), lowestValue.getValue(i).toString()); } }
### Question: HighestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } HighestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), highestValue.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num closePrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, closePrice, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) assertEquals(series.getBar(i - 1).getClosePrice().toString(), highestValue.getValue(i).toString()); else assertEquals(series.getBar(i).getClosePrice().toString(), highestValue.getValue(i).toString()); } }
### Question: ConstantIndicator extends AbstractIndicator<T> { public ConstantIndicator(BarSeries series, T t) { super(series); this.value = t; } ConstantIndicator(BarSeries series, T t); @Override T getValue(int index); @Override String toString(); }### Answer: @Test public void constantIndicator() { assertNumEquals("30.33", constantIndicator.getValue(0)); assertNumEquals("30.33", constantIndicator.getValue(1)); assertNumEquals("30.33", constantIndicator.getValue(10)); assertNumEquals("30.33", constantIndicator.getValue(30)); }
### Question: FixedIndicator extends AbstractIndicator<T> { @Override public T getValue(int index) { return values.get(index); } @SafeVarargs FixedIndicator(BarSeries series, T... values); void addValue(T value); @Override T getValue(int index); }### Answer: @Test public void getValueOnFixedDecimalIndicator() { BarSeries series = new BaseBarSeries(); FixedDecimalIndicator fixedDecimalIndicator = new FixedDecimalIndicator(series, 13.37, 42, -17); assertNumEquals(13.37, fixedDecimalIndicator.getValue(0)); assertNumEquals(42, fixedDecimalIndicator.getValue(1)); assertNumEquals(-17, fixedDecimalIndicator.getValue(2)); fixedDecimalIndicator = new FixedDecimalIndicator(series, "3.0", "-123.456", "0.0"); assertNumEquals("3.0", fixedDecimalIndicator.getValue(0)); assertNumEquals("-123.456", fixedDecimalIndicator.getValue(1)); assertNumEquals("0.0", fixedDecimalIndicator.getValue(2)); } @Test public void getValueOnFixedBooleanIndicator() { BarSeries series = new BaseBarSeries(); FixedBooleanIndicator fixedBooleanIndicator = new FixedBooleanIndicator(series, false, false, true, false, true); Assert.assertFalse(fixedBooleanIndicator.getValue(0)); Assert.assertFalse(fixedBooleanIndicator.getValue(1)); Assert.assertTrue(fixedBooleanIndicator.getValue(2)); Assert.assertFalse(fixedBooleanIndicator.getValue(3)); Assert.assertTrue(fixedBooleanIndicator.getValue(4)); }
### Question: InPipeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = ref.getValue(index).isLessThanOrEqual(upper.getValue(index)) && ref.getValue(index).isGreaterThanOrEqual(lower.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } InPipeRule(Indicator<Num> ref, Number upper, Number lower); InPipeRule(Indicator<Num> ref, Num upper, Num lower); InPipeRule(Indicator<Num> ref, Indicator<Num> upper, Indicator<Num> lower); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); }
### Question: WMAIndicator extends CachedIndicator<Num> { @Override protected Num calculate(int index) { if (index == 0) { return indicator.getValue(0); } Num value = numOf(0); if (index - barCount < 0) { for (int i = index + 1; i > 0; i--) { value = value.plus(numOf(i).multipliedBy(indicator.getValue(i - 1))); } return value.dividedBy(numOf(((index + 1) * (index + 2)) / 2)); } int actualIndex = index; for (int i = barCount; i > 0; i--) { value = value.plus(numOf(i).multipliedBy(indicator.getValue(actualIndex))); actualIndex--; } return value.dividedBy(numOf((barCount * (barCount + 1)) / 2)); } WMAIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void calculate() { MockBarSeries series = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d, 6d); Indicator<Num> close = new ClosePriceIndicator(series); Indicator<Num> wmaIndicator = new WMAIndicator(close, 3); assertNumEquals(1, wmaIndicator.getValue(0)); assertNumEquals(1.6667, wmaIndicator.getValue(1)); assertNumEquals(2.3333, wmaIndicator.getValue(2)); assertNumEquals(3.3333, wmaIndicator.getValue(3)); assertNumEquals(4.3333, wmaIndicator.getValue(4)); assertNumEquals(5.3333, wmaIndicator.getValue(5)); }
### Question: AroonDownIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } AroonDownIndicator(Indicator<Num> minValueIndicator, int barCount); AroonDownIndicator(BarSeries series, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("NaN test").build(); for (long i = 0; i <= 1000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } AroonDownIndicator aroonDownIndicator = new AroonDownIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), aroonDownIndicator.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(numFunction).withName("NaN test").build(); for (long i = 10; i >= 0; i--) { Num minPrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(10 - i), NaN, NaN, minPrice, NaN, NaN); } series.addBar(ZonedDateTime.now().plusDays(11), NaN, NaN, series.numOf(10), NaN, NaN); AroonDownIndicator 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)); else assertNumEquals(series.numOf(80).toString(), aroonDownIndicator.getValue(i)); } }
### Question: BollingerBandsLowerIndicator extends CachedIndicator<Num> { public Num getK() { return k; } BollingerBandsLowerIndicator(BollingerBandsMiddleIndicator bbm, Indicator<Num> indicator); BollingerBandsLowerIndicator(BollingerBandsMiddleIndicator bbm, Indicator<Num> indicator, Num k); Num getK(); @Override String toString(); }### Answer: @Test public void bollingerBandsLowerUsingSMAAndStandardDeviation() { BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePrice, barCount); BollingerBandsLowerIndicator bblSMA = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation); assertNumEquals(2, bblSMA.getK()); assertNumEquals(1, bblSMA.getValue(0)); assertNumEquals(0.5, bblSMA.getValue(1)); assertNumEquals(0.367, bblSMA.getValue(2)); assertNumEquals(1.367, bblSMA.getValue(3)); assertNumEquals(2.3905, bblSMA.getValue(4)); assertNumEquals(2.7239, bblSMA.getValue(5)); assertNumEquals(2.367, bblSMA.getValue(6)); BollingerBandsLowerIndicator bblSMAwithK = new BollingerBandsLowerIndicator(bbmSMA, standardDeviation, numFunction.apply(1.5)); assertNumEquals(1.5, bblSMAwithK.getK()); assertNumEquals(1, bblSMAwithK.getValue(0)); assertNumEquals(0.75, bblSMAwithK.getValue(1)); assertNumEquals(0.7752, bblSMAwithK.getValue(2)); assertNumEquals(1.7752, bblSMAwithK.getValue(3)); assertNumEquals(2.6262, bblSMAwithK.getValue(4)); assertNumEquals(2.9595, bblSMAwithK.getValue(5)); assertNumEquals(2.7752, bblSMAwithK.getValue(6)); }
### Question: BollingerBandsUpperIndicator extends CachedIndicator<Num> { public Num getK() { return k; } BollingerBandsUpperIndicator(BollingerBandsMiddleIndicator bbm, Indicator<Num> deviation); BollingerBandsUpperIndicator(BollingerBandsMiddleIndicator bbm, Indicator<Num> deviation, Num k); Num getK(); @Override String toString(); }### Answer: @Test public void bollingerBandsUpperUsingSMAAndStandardDeviation() { BollingerBandsMiddleIndicator bbmSMA = new BollingerBandsMiddleIndicator(sma); StandardDeviationIndicator standardDeviation = new StandardDeviationIndicator(closePrice, barCount); BollingerBandsUpperIndicator bbuSMA = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation); assertNumEquals(2, bbuSMA.getK()); assertNumEquals(1, bbuSMA.getValue(0)); assertNumEquals(2.5, bbuSMA.getValue(1)); assertNumEquals(3.633, bbuSMA.getValue(2)); assertNumEquals(4.633, bbuSMA.getValue(3)); assertNumEquals(4.2761, bbuSMA.getValue(4)); assertNumEquals(4.6094, bbuSMA.getValue(5)); assertNumEquals(5.633, bbuSMA.getValue(6)); assertNumEquals(5.2761, bbuSMA.getValue(7)); assertNumEquals(5.633, bbuSMA.getValue(8)); assertNumEquals(4.2761, bbuSMA.getValue(9)); BollingerBandsUpperIndicator bbuSMAwithK = new BollingerBandsUpperIndicator(bbmSMA, standardDeviation, numFunction.apply(1.5)); assertNumEquals(1.5, bbuSMAwithK.getK()); assertNumEquals(1, bbuSMAwithK.getValue(0)); assertNumEquals(2.25, bbuSMAwithK.getValue(1)); assertNumEquals(3.2247, bbuSMAwithK.getValue(2)); assertNumEquals(4.2247, bbuSMAwithK.getValue(3)); assertNumEquals(4.0404, bbuSMAwithK.getValue(4)); assertNumEquals(4.3737, bbuSMAwithK.getValue(5)); assertNumEquals(5.2247, bbuSMAwithK.getValue(6)); assertNumEquals(5.0404, bbuSMAwithK.getValue(7)); assertNumEquals(5.2247, bbuSMAwithK.getValue(8)); assertNumEquals(4.0404, bbuSMAwithK.getValue(9)); }
### Question: KeltnerChannelUpperIndicator extends CachedIndicator<Num> { public KeltnerChannelUpperIndicator(KeltnerChannelMiddleIndicator keltnerMiddleIndicator, double ratio, int barCountATR) { super(keltnerMiddleIndicator); this.ratio = numOf(ratio); this.keltnerMiddleIndicator = keltnerMiddleIndicator; averageTrueRangeIndicator = new ATRIndicator(keltnerMiddleIndicator.getBarSeries(), barCountATR); } KeltnerChannelUpperIndicator(KeltnerChannelMiddleIndicator keltnerMiddleIndicator, double ratio, int barCountATR); }### Answer: @Test public void keltnerChannelUpperIndicatorTest() { KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); KeltnerChannelUpperIndicator ku = new KeltnerChannelUpperIndicator(km, 2, 14); assertNumEquals(11971.9132, ku.getValue(13)); assertNumEquals(12002.3402, ku.getValue(14)); assertNumEquals(12024.4032, ku.getValue(15)); assertNumEquals(12040.3933, ku.getValue(16)); assertNumEquals(12052.8572, ku.getValue(17)); assertNumEquals(12067.9050, ku.getValue(18)); assertNumEquals(12099.5025, ku.getValue(19)); assertNumEquals(12110.5722, ku.getValue(20)); assertNumEquals(12130.8675, ku.getValue(21)); assertNumEquals(12147.7344, ku.getValue(22)); assertNumEquals(12175.5937, ku.getValue(23)); assertNumEquals(12208.1327, ku.getValue(24)); assertNumEquals(12233.9032, ku.getValue(25)); assertNumEquals(12256.9596, ku.getValue(26)); assertNumEquals(12285.9094, ku.getValue(27)); assertNumEquals(12301.1108, ku.getValue(28)); assertNumEquals(12313.2042, ku.getValue(29)); }
### Question: KeltnerChannelLowerIndicator extends CachedIndicator<Num> { public KeltnerChannelLowerIndicator(KeltnerChannelMiddleIndicator keltnerMiddleIndicator, double ratio, int barCountATR) { super(keltnerMiddleIndicator); this.ratio = numOf(ratio); this.keltnerMiddleIndicator = keltnerMiddleIndicator; averageTrueRangeIndicator = new ATRIndicator(keltnerMiddleIndicator.getBarSeries(), barCountATR); } KeltnerChannelLowerIndicator(KeltnerChannelMiddleIndicator keltnerMiddleIndicator, double ratio, int barCountATR); }### Answer: @Test public void keltnerChannelLowerIndicatorTest() { KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); KeltnerChannelLowerIndicator kl = new KeltnerChannelLowerIndicator(km, 2, 14); assertNumEquals(11556.5468, kl.getValue(13)); assertNumEquals(11583.7971, kl.getValue(14)); assertNumEquals(11610.8331, kl.getValue(15)); assertNumEquals(11639.5955, kl.getValue(16)); assertNumEquals(11667.0877, kl.getValue(17)); assertNumEquals(11660.5619, kl.getValue(18)); assertNumEquals(11675.8782, kl.getValue(19)); assertNumEquals(11705.9497, kl.getValue(20)); assertNumEquals(11726.7208, kl.getValue(21)); assertNumEquals(11753.4154, kl.getValue(22)); assertNumEquals(11781.8375, kl.getValue(23)); assertNumEquals(11817.1476, kl.getValue(24)); assertNumEquals(11851.9771, kl.getValue(25)); assertNumEquals(11878.6139, kl.getValue(26)); assertNumEquals(11904.4570, kl.getValue(27)); assertNumEquals(11935.3907, kl.getValue(28)); assertNumEquals(11952.2012, kl.getValue(29)); }
### Question: KeltnerChannelMiddleIndicator extends CachedIndicator<Num> { public KeltnerChannelMiddleIndicator(BarSeries series, int barCountEMA) { this(new TypicalPriceIndicator(series), barCountEMA); } KeltnerChannelMiddleIndicator(BarSeries series, int barCountEMA); KeltnerChannelMiddleIndicator(Indicator<Num> indicator, int barCountEMA); }### Answer: @Test public void keltnerChannelMiddleIndicatorTest() { KeltnerChannelMiddleIndicator km = new KeltnerChannelMiddleIndicator(new ClosePriceIndicator(data), 14); assertNumEquals(11764.23, km.getValue(13)); assertNumEquals(11793.0687, km.getValue(14)); assertNumEquals(11817.6182, km.getValue(15)); assertNumEquals(11839.9944, km.getValue(16)); assertNumEquals(11859.9725, km.getValue(17)); assertNumEquals(11864.2335, km.getValue(18)); assertNumEquals(11887.6903, km.getValue(19)); assertNumEquals(11908.2609, km.getValue(20)); assertNumEquals(11928.7941, km.getValue(21)); assertNumEquals(11950.5749, km.getValue(22)); assertNumEquals(11978.7156, km.getValue(23)); assertNumEquals(12012.6402, km.getValue(24)); assertNumEquals(12042.9401, km.getValue(25)); assertNumEquals(12067.7868, km.getValue(26)); assertNumEquals(12095.1832, km.getValue(27)); assertNumEquals(12118.2508, km.getValue(28)); assertNumEquals(12132.7027, km.getValue(29)); }
### Question: BarSeriesManager { public TradingRecord run(Strategy strategy) { return run(strategy, OrderType.BUY); } BarSeriesManager(); BarSeriesManager(BarSeries barSeries); BarSeriesManager(BarSeries barSeries, CostModel transactionCostModel, CostModel holdingCostModel); void setBarSeries(BarSeries barSeries); BarSeries getBarSeries(); TradingRecord run(Strategy strategy); TradingRecord run(Strategy strategy, int startIndex, int finishIndex); TradingRecord run(Strategy strategy, OrderType orderType); TradingRecord run(Strategy strategy, OrderType orderType, int startIndex, int finishIndex); TradingRecord run(Strategy strategy, OrderType orderType, Num amount); TradingRecord run(Strategy strategy, OrderType orderType, Num amount, int startIndex, int finishIndex); }### Answer: @Test public void runOnSeries() { List<Trade> trades = manager.run(strategy).getTrades(); assertEquals(2, trades.size()); assertEquals(Order.buyAt(2, seriesForRun.getBar(2).getClosePrice(), numOf(1)), trades.get(0).getEntry()); assertEquals(Order.sellAt(4, seriesForRun.getBar(4).getClosePrice(), numOf(1)), trades.get(0).getExit()); assertEquals(Order.buyAt(6, seriesForRun.getBar(6).getClosePrice(), numOf(1)), trades.get(1).getEntry()); assertEquals(Order.sellAt(7, seriesForRun.getBar(7).getClosePrice(), numOf(1)), trades.get(1).getExit()); } @Test public void runWithOpenEntryBuyLeft() { Strategy aStrategy = new BaseStrategy(new FixedRule(1), new FixedRule(3)); List<Trade> trades = manager.run(aStrategy, 0, 3).getTrades(); assertEquals(1, trades.size()); assertEquals(Order.buyAt(1, seriesForRun.getBar(1).getClosePrice(), numOf(1)), trades.get(0).getEntry()); assertEquals(Order.sellAt(3, seriesForRun.getBar(3).getClosePrice(), numOf(1)), trades.get(0).getExit()); } @Test public void runWithOpenEntrySellLeft() { Strategy aStrategy = new BaseStrategy(new FixedRule(1), new FixedRule(3)); List<Trade> trades = manager.run(aStrategy, OrderType.SELL, 0, 3).getTrades(); assertEquals(1, trades.size()); assertEquals(Order.sellAt(1, seriesForRun.getBar(1).getClosePrice(), numOf(1)), trades.get(0).getEntry()); assertEquals(Order.buyAt(3, seriesForRun.getBar(3).getClosePrice(), numOf(1)), trades.get(0).getExit()); } @Test public void runBetweenIndexes() { List<Trade> trades = manager.run(strategy, 0, 3).getTrades(); assertEquals(1, trades.size()); assertEquals(Order.buyAt(2, seriesForRun.getBar(2).getClosePrice(), numOf(1)), trades.get(0).getEntry()); assertEquals(Order.sellAt(4, seriesForRun.getBar(4).getClosePrice(), numOf(1)), trades.get(0).getExit()); trades = manager.run(strategy, 4, 4).getTrades(); assertTrue(trades.isEmpty()); trades = manager.run(strategy, 5, 8).getTrades(); assertEquals(1, trades.size()); assertEquals(Order.buyAt(6, seriesForRun.getBar(6).getClosePrice(), numOf(1)), trades.get(0).getEntry()); assertEquals(Order.sellAt(7, seriesForRun.getBar(7).getClosePrice(), numOf(1)), trades.get(0).getExit()); }
### Question: FixedRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; for (int idx : indexes) { if (idx == index) { satisfied = true; break; } } traceIsSatisfied(index, satisfied); return satisfied; } FixedRule(int... indexes); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { FixedRule fixedRule = new FixedRule(); assertFalse(fixedRule.isSatisfied(0)); assertFalse(fixedRule.isSatisfied(1)); assertFalse(fixedRule.isSatisfied(2)); assertFalse(fixedRule.isSatisfied(9)); fixedRule = new FixedRule(1, 2, 3); assertFalse(fixedRule.isSatisfied(0)); assertTrue(fixedRule.isSatisfied(1)); assertTrue(fixedRule.isSatisfied(2)); assertTrue(fixedRule.isSatisfied(3)); assertFalse(fixedRule.isSatisfied(4)); assertFalse(fixedRule.isSatisfied(5)); assertFalse(fixedRule.isSatisfied(6)); assertFalse(fixedRule.isSatisfied(7)); assertFalse(fixedRule.isSatisfied(8)); assertFalse(fixedRule.isSatisfied(9)); assertFalse(fixedRule.isSatisfied(10)); }
### Question: Returns implements Indicator<Num> { public int getSize() { return barSeries.getBarCount() - 1; } Returns(BarSeries barSeries, Trade trade, ReturnType type); Returns(BarSeries barSeries, TradingRecord tradingRecord, ReturnType type); List<Num> getValues(); @Override Num getValue(int index); @Override BarSeries getBarSeries(); @Override Num numOf(Number number); int getSize(); void calculate(Trade trade); void calculate(Trade trade, int finalIndex); }### Answer: @Test public void returnSize() { for (Returns.ReturnType type : Returns.ReturnType.values()) { BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); Returns returns = new Returns(sampleBarSeries, new BaseTradingRecord(), type); assertEquals(4, returns.getSize()); } }
### Question: CashFlow implements Indicator<Num> { public int getSize() { return barSeries.getBarCount(); } CashFlow(BarSeries barSeries, Trade trade); CashFlow(BarSeries barSeries, TradingRecord tradingRecord); CashFlow(BarSeries barSeries, TradingRecord tradingRecord, int finalIndex); @Override Num getValue(int index); @Override BarSeries getBarSeries(); @Override Num numOf(Number number); int getSize(); }### Answer: @Test public void cashFlowSize() { BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); CashFlow cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); assertEquals(5, cashFlow.getSize()); }
### Question: IsLowestRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { LowestValueIndicator lowest = new LowestValueIndicator(ref, barCount); Num lowestVal = lowest.getValue(index); Num refVal = ref.getValue(index); final boolean satisfied = !refVal.isNaN() && !lowestVal.isNaN() && refVal.equals(lowestVal); traceIsSatisfied(index, satisfied); return satisfied; } IsLowestRule(Indicator<Num> ref, int barCount); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: NumberOfLosingTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isLosingTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(1, series), Order.sellAt(3, series), Order.buyAt(3, series), Order.sellAt(4, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(1, series), Order.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
### Question: NumberOfLosingTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: VersusBuyAndHoldCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } VersusBuyAndHoldCriterion(AnalysisCriterion criterion); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(new TotalProfitCriterion()); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: NumberOfWinningTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isWinningTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(2, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
### Question: NotRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = !ruleToNegate.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } NotRule(Rule ruleToNegate); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRuleToNegate(); }### Answer: @Test public void isSatisfied() { assertFalse(satisfiedRule.negation().isSatisfied(0)); assertTrue(unsatisfiedRule.negation().isSatisfied(0)); assertFalse(satisfiedRule.negation().isSatisfied(10)); assertTrue(unsatisfiedRule.negation().isSatisfied(10)); }
### Question: NumberOfWinningTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: BuyAndHoldCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.getBar(series.getEndIndex()).getClosePrice() .dividedBy(series.getBar(series.getBeginIndex()).getClosePrice()); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(1.05, buyAndHold.calculate(series, tradingRecord)); } @Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0.7, buyAndHold.calculate(series, tradingRecord)); } @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0.7, buyAndHold.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(105d / 100, buyAndHold.calculate(series, trade)); }
### Question: BuyAndHoldCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(1.3), numOf(1.1))); assertFalse(criterion.betterThan(numOf(0.6), numOf(0.9))); }
### Question: NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(t -> calculate(series, t)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(0, numberOfBars.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(6, numberOfBars.calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); Trade t = new Trade(Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(4, numberOfBars.calculate(series, t)); }
### Question: AndRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) && rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } AndRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertFalse(satisfiedRule.and(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.and(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.and(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.and(unsatisfiedRule).isSatisfied(0)); assertTrue(satisfiedRule.and(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.and(satisfiedRule).isSatisfied(10)); assertFalse(unsatisfiedRule.and(BooleanRule.TRUE).isSatisfied(10)); assertFalse(BooleanRule.TRUE.and(unsatisfiedRule).isSatisfied(10)); }
### Question: RESTService extends Service { @Override public final String getAlias() { try { String pathPrefix = null; for (Annotation classAnnotation : this.getClass().getAnnotations()) { if (classAnnotation instanceof ServicePath) { pathPrefix = ((ServicePath) classAnnotation).value(); break; } } if (pathPrefix == null) { throw new Exception("ServicePath annotation for service class is required!"); } pathPrefix = pathPrefix.trim(); pathPrefix = pathPrefix.replaceAll("(^/)|(/$)", ""); if (pathPrefix.length() == 0) { throw new Exception("ServicePath annotation for service class is required!"); } return pathPrefix; } catch (Exception e) { } return null; } RESTService(); final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers); final String getSwagger(); @Override final String getAlias(); }### Answer: @Test public void testAlias() { assertEquals("service1", testee.getAlias()); }
### Question: ServiceAliasManager { public AliasResolveResponse resolvePathToServiceName(String path) throws AliasNotFoundException { List<String> split = splitPath(path); int level = 0; String currentKey = null; while (level < split.size() && level < MAX_PATH_LEVEL) { if (currentKey == null) { currentKey = split.get(level); } else { currentKey += SEPERATOR + split.get(level); } String currentEntry = null; try { currentEntry = getEntry(currentKey); } catch (EnvelopeException | CryptoException | AgentAccessDeniedException | SerializationException e) { throw new AliasNotFoundException("Path does not exist.", e); } if (!currentEntry.equals(BLANK)) { return new AliasResolveResponse(currentEntry, level + 1); } level++; } if (level == MAX_PATH_LEVEL) { throw new AliasNotFoundException("Given path is too long."); } throw new AliasNotFoundException("Given path does not fit any alias."); } ServiceAliasManager(Node node); void registerServiceAlias(ServiceAgentImpl agent, String alias); AliasResolveResponse resolvePathToServiceName(String path); }### Answer: @Test public void testIntegration() throws CryptoException, InternalSecurityException, AgentAlreadyRegisteredException, AgentException, AliasNotFoundException, AgentAccessDeniedException { LocalNode node = new LocalNodeManager().launchNode(); node.startService(ServiceNameVersion.fromString("[email protected]"), "asdf"); assertEquals("i5.las2peer.api.TestService", node.getServiceAliasManager().resolvePathToServiceName("test").getServiceName()); }
### Question: NodeServiceCache { public ServiceInstance getServiceAgentInstance(ServiceNameVersion service, boolean exact, boolean localOnly, AgentImpl acting) throws AgentNotRegisteredException { ServiceInstance local = null, global = null; if (exact) { synchronized (localServices) { if (localServices.containsKey(service.getName()) && localServices.get(service.getName()).containsKey(service.getVersion())) { local = localServices.get(service.getName()).get(service.getVersion()); } } } else { synchronized (localServices) { if (localServices.containsKey(service.getName())) { for (Map.Entry<ServiceVersion, ServiceInstance> e : localServices.get(service.getName()) .entrySet()) { if (e.getKey().fits(service.getVersion())) { local = e.getValue(); break; } } } } } if (!localOnly && (local == null || runningAt.isBusy())) { if (exact) { ServiceInstance instance = getBestGlobalInstanceOfVersion(service.getName(), service.getVersion()); if (instance == null) { try { update(service, true, acting); } catch (Exception e) { if (e instanceof TimeoutException) { logger.log(Level.INFO, "Timeout while updating service cache. " + e.toString()); } else { logger.log(Level.INFO, "Could not update service cache", e); } if (local == null) { throw new AgentNotRegisteredException( "Could not retrieve service information from the network.", e); } } instance = getBestGlobalInstanceOfVersion(service.getName(), service.getVersion()); } if (instance != null) { global = instance; } } else { ServiceInstance instance = getBestGlobalInstanceFitsVersion(service.getName(), service.getVersion()); if (instance != null) { global = instance; } if (instance == null) { try { update(service, false, acting); } catch (Exception e) { if (e instanceof TimeoutException) { logger.log(Level.INFO, "Timeout while updating service cache. " + e.toString()); } else { logger.log(Level.INFO, "Could not update service cache", e); } if (local == null) { throw new AgentNotRegisteredException( "Could not retrieve service information from the network.", e); } } instance = getBestGlobalInstanceFitsVersion(service.getName(), service.getVersion()); } if (instance != null) { global = instance; } } } if (local != null && (!runningAt.isBusy() || global == null)) { return local; } else if (global != null) { return global; } throw new AgentNotRegisteredException("Could not find any agent for this service on the network!"); } NodeServiceCache(Node parent, long lifeTime, int resultCount); void setWaitForResults(int c); void setLifeTimeSeconds(int c); void setTimeoutMs(int timeoutMs); void clear(); ServiceInstance getServiceAgentInstance(ServiceNameVersion service, boolean exact, boolean localOnly, AgentImpl acting); void removeGlobalServiceInstance(ServiceInstance instance); void registerLocalService(ServiceAgentImpl agent); void unregisterLocalService(ServiceAgentImpl agent); ServiceAgentImpl getLocalService(ServiceNameVersion service); List<String> getLocalServiceNames(); List<ServiceVersion> getLocalServiceVersions(String serviceName); }### Answer: @Test public void testIntegration() { try { ServiceNameVersion serviceNameVersion = ServiceNameVersion .fromString("[email protected]"); LocalNode serviceNode = new LocalNodeManager().newNode("export/jars/"); serviceNode.launch(); ServiceAgentImpl serviceAgent = serviceNode.startService(serviceNameVersion, "a pass"); ServiceAgentImpl localServiceAgent = serviceNode.getNodeServiceCache() .getServiceAgentInstance(serviceNameVersion, true, true, null).getServiceAgent(); assertSame(serviceAgent, localServiceAgent); serviceNode.stopService(serviceAgent); try { serviceNode.getNodeServiceCache().getServiceAgentInstance(serviceNameVersion, true, true, null); fail("AgentNotRegisteredException exptected!"); } catch (AgentNotRegisteredException e) { } } catch (Exception e) { e.printStackTrace(); Assert.fail(e.toString()); } }
### Question: MessageEnvelope implements Message { public String getContent() { return content; } MessageEnvelope(NodeHandle sendingNode, String content); MessageEnvelope(NodeHandle sendingNode, i5.las2peer.communication.Message content); NodeHandle getSendingNode(); String getContent(); i5.las2peer.communication.Message getContainedMessage(); @Override int getPriority(); }### Answer: @Test public void testSimpleContent() { try { String data = "some data to test"; MessageEnvelope testee = new MessageEnvelope(null, data); byte[] serialized = SerializeTools.serialize(testee); MessageEnvelope andBack = (MessageEnvelope) SerializeTools.deserialize(serialized); assertEquals(data, andBack.getContent()); } catch (Exception e) { e.printStackTrace(); Assert.fail(e.toString()); } }
### Question: PastryNodeImpl extends Node { @Override public synchronized void shutDown() { this.setStatus(NodeStatus.CLOSING); super.shutDown(); if (threadpool != null) { threadpool.shutdownNow(); } if (pastryNode != null) { pastryNode.destroy(); pastryNode = null; } if (pastryEnvironment != null) { pastryEnvironment.destroy(); pastryEnvironment = null; } this.setStatus(NodeStatus.CLOSED); } PastryNodeImpl(String bootstrap, STORAGE_MODE storageMode, String storageDir, Long nodeIdSeed); PastryNodeImpl(ClassManager classManager, boolean useMonitoringObserver, InetAddress pastryBindAddress, Integer pastryPort, List<String> bootstrap, STORAGE_MODE storageMode, String storageDir, Long nodeIdSeed); PastryNode getPastryNode(); @Override synchronized void shutDown(); @Override synchronized void registerReceiver(MessageReceiver receiver); @Override synchronized void unregisterReceiver(MessageReceiver receiver); @Override synchronized void registerReceiverToTopic(MessageReceiver receiver, long topic); @Override synchronized void unregisterReceiverFromTopic(MessageReceiver receiver, long topic); @Override void sendMessage(Message message, MessageResultListener listener, SendMode mode); @Override void sendMessage(Message message, Object atNodeId, MessageResultListener listener); @Deprecated @Override EnvelopeVersion fetchArtifact(long id); @Deprecated @Override EnvelopeVersion fetchArtifact(String identifier); @Deprecated @Override void storeArtifact(EnvelopeVersion envelope); @Deprecated @Override void removeArtifact(long id, byte[] signature); @Override Object[] findRegisteredAgent(String agentId, int hintOfExpectedCount); NodeApplication getApplication(); @Override AgentImpl getAgent(String id); @Override void storeAgent(AgentImpl agent); @Deprecated @Override void updateAgent(AgentImpl agent); @Override Serializable getNodeId(); InetAddress getBindAddress(); int getPort(); @Override Object[] getOtherKnownNodes(); @Override NodeInformation getNodeInformation(Object nodeId); long getLocalStorageSize(); long getLocalMaxStorageSize(); @Override void storeEnvelope(EnvelopeVersion envelope, AgentImpl author); @Override EnvelopeVersion fetchEnvelope(String identifier); @Override EnvelopeVersion createEnvelope(String identifier, PublicKey authorPubKey, Serializable content, AgentImpl... reader); @Override EnvelopeVersion createEnvelope(String identifier, PublicKey authorPubKey, Serializable content, Collection<?> readers); @Override EnvelopeVersion createEnvelope(EnvelopeVersion previousVersion, Serializable content); @Override EnvelopeVersion createEnvelope(EnvelopeVersion previousVersion, Serializable content, AgentImpl... reader); @Override EnvelopeVersion createEnvelope(EnvelopeVersion previousVersion, Serializable content, Collection<?> readers); @Override EnvelopeVersion createUnencryptedEnvelope(String identifier, PublicKey authorPubKey, Serializable content); @Override EnvelopeVersion createUnencryptedEnvelope(EnvelopeVersion previousVersion, Serializable content); @Override void storeEnvelope(EnvelopeVersion envelope, AgentImpl author, long timeoutMs); @Override void storeEnvelopeAsync(EnvelopeVersion envelope, AgentImpl author, StorageStoreResultHandler resultHandler, StorageCollisionHandler collisionHandler, StorageExceptionHandler exceptionHandler); @Override EnvelopeVersion fetchEnvelope(String identifier, long timeoutMs); @Override void fetchEnvelopeAsync(String identifier, StorageEnvelopeHandler envelopeHandler, StorageExceptionHandler exceptionHandler); @Override void removeEnvelope(String identifier); void storeHashedContentAsync(byte[] content, StorageStoreResultHandler resultHandler, StorageExceptionHandler exceptionHandler); void storeHashedContent(byte[] content); void storeHashedContent(byte[] content, long timeoutMs); void fetchHashedContentAsync(byte[] hash, StorageArtifactHandler artifactHandler, StorageExceptionHandler exceptionHandler); byte[] fetchHashedContent(byte[] hash); byte[] fetchHashedContent(byte[] hash, long timeoutMs); static final int DEFAULT_BOOTSTRAP_PORT; }### Answer: @Test public void testNodeRestart() { PastryNodeImpl testNode = null; try { testNode = TestSuite.launchNetwork(1).get(0); testNode.shutDown(); testNode.launch(); testNode.shutDown(); } catch (Exception e) { e.printStackTrace(); Assert.fail(e.toString()); } finally { testNode.shutDown(); System.out.println("Node stopped"); } }
### Question: ServiceClassLoader extends ClassLoader { public LoadedLibrary getLibrary() { return library; } ServiceClassLoader(LoadedLibrary lib, ClassLoader parent, ClassLoaderPolicy policy); LoadedLibrary getLibrary(); @Override URL getResource(String resourceName); }### Answer: @Test public void test() throws IllegalArgumentException, IOException { LoadedLibrary lib = LoadedJarLibrary .createFromJar("export/jars/i5.las2peer.classLoaders.testPackage2-1.0.jar"); ServiceClassLoader testee = new ServiceClassLoader(lib, null, new DefaultPolicy()); assertEquals("i5.las2peer.classLoaders.testPackage2", testee.getLibrary().getIdentifier().getName()); assertEquals("1.0", testee.getLibrary().getIdentifier().getVersion().toString()); }
### Question: RESTService extends Service { public final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers) { final ResponseWriter responseWriter = new ResponseWriter(); final ContainerRequest requestContext = new ContainerRequest(baseUri, requestUri, method, getSecurityContext(), new MapPropertiesDelegate()); requestContext.setEntityStream(new ByteArrayInputStream(body)); requestContext.getHeaders().putAll(headers); requestContext.setWriter(responseWriter); try { appHandler.handle(requestContext); } finally { responseWriter.commit(); } return responseWriter.getResponse(); } RESTService(); final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers); final String getSwagger(); @Override final String getAlias(); }### Answer: @Test public void testHandle() throws URISyntaxException { RESTResponse response = invoke(testee, "GET", "hello", ""); assertEquals(200, response.getHttpCode()); assertEquals("Hello World!", new String(response.getBody())); }
### Question: ServiceClassLoader extends ClassLoader { URL getResource(String resourceName, boolean lookUp) { Logger.logGetResource(this, resourceName, null, lookUp); URL res; try { res = library.getResourceAsUrl(resourceName); } catch (ResourceNotFoundException e) { if (lookUp && parent != null) { URL result = parent.getResource(resourceName); if (result != null) { return result; } else { Logger.logGetResource(this, resourceName, false, null); return null; } } else { Logger.logGetResource(this, resourceName, false, null); return null; } } if (res != null) { Logger.logGetResource(this, resourceName, true, null); return res; } else { return null; } } ServiceClassLoader(LoadedLibrary lib, ClassLoader parent, ClassLoaderPolicy policy); LoadedLibrary getLibrary(); @Override URL getResource(String resourceName); }### Answer: @Test public void testResources() throws IllegalArgumentException, IOException { LoadedLibrary lib = LoadedJarLibrary .createFromJar("export/jars/i5.las2peer.classLoaders.testPackage1-1.0.jar"); ServiceClassLoader testee = new ServiceClassLoader(lib, null, new DefaultPolicy()); Properties properties = new Properties(); properties.load(testee.getResourceAsStream("i5/las2peer/classLoaders/testPackage1/test.properties")); assertEquals("123", properties.getProperty("integer")); assertEquals("value", properties.getProperty("attribute")); URL test = testee.getResource("does/not/exist"); assertNull(test); }
### Question: ClassManager { public static final String getPackageName(String className) { if (className.indexOf('.') < 0) { throw new IllegalArgumentException("this class is not contained in a package!"); } return className.substring(0, className.lastIndexOf('.')); } ClassManager(Repository repository, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(Repository[] repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(List<Repository> repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); void registerService(ServiceNameVersion serviceIdentifier); void unregisterService(ServiceNameVersion service); Class<?> getServiceClass(ServiceNameVersion service); static final String getPackageName(String className); void addRepository(Repository repository); }### Answer: @Test public void testPackageName() { assertEquals("my.package", ClassManager.getPackageName("my.package.Class")); try { ClassManager.getPackageName("teststring"); fail("IllegalArgumentException should have been thrown"); } catch (IllegalArgumentException e) { } }
### Question: ClassManager { public Class<?> getServiceClass(ServiceNameVersion service) throws ClassLoaderException { ServiceClassLoader cl = registeredLoaders.get(service); if (cl == null) { try { registerService(service); cl = registeredLoaders.get(service); } catch (LibraryNotFoundException e) { System.err.println("No library found for " + service + "! Trying default classpath. This should not happen in a productive environment!"); try { return this.platformLoader.loadClass(service.getName()); } catch (ClassNotFoundException e2) { throw e; } } } try { return cl.loadClass(service.getName()); } catch (ClassNotFoundException e) { throw new LibraryNotFoundException( "The library for " + service + " could be loaded, but the class is not available!", e); } } ClassManager(Repository repository, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(Repository[] repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(List<Repository> repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); void registerService(ServiceNameVersion serviceIdentifier); void unregisterService(ServiceNameVersion service); Class<?> getServiceClass(ServiceNameVersion service); static final String getPackageName(String className); void addRepository(Repository repository); }### Answer: @Test public void testServiceClassLoading() throws ClassLoaderException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { ClassManager testee = new ClassManager(new FileSystemRepository("export/jars/"), ClassLoader.getSystemClassLoader(), new DefaultPolicy()); Class<?> cl = testee.getServiceClass(ServiceNameVersion.fromString("[email protected]")); assertFalse(cl.getClassLoader().equals(ClassLoader.getSystemClassLoader())); Method m = cl.getDeclaredMethod("countCalls"); Object result = m.invoke(null); result = m.invoke(null); assertEquals(-2, ((Integer) result).intValue()); Class<?> cl1 = testee.getServiceClass(new ServiceNameVersion("i5.las2peer.testServices.testPackage1.TestService", "1.0")); Class<?> cl2 = testee.getServiceClass(new ServiceNameVersion("i5.las2peer.testServices.testPackage1.TestService", "1.1")); Method m1 = cl1.getDeclaredMethod("getVersionStatic"); Method m2 = cl2.getDeclaredMethod("getVersionStatic"); assertEquals(m1.invoke(null), 100); assertEquals(m2.invoke(null), 110); } @Test public void testMultipleServiceClassLoading() throws ClassLoaderException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { ClassManager testee = new ClassManager(new FileSystemRepository("export/jars/"), ClassLoader.getSystemClassLoader(), new DefaultPolicy()); Class<?> cl1 = testee.getServiceClass(new ServiceNameVersion("i5.las2peer.classLoaders.testPackage2.UsingCounter", "1.0")); Class<?> cl2 = testee.getServiceClass(new ServiceNameVersion("i5.las2peer.classLoaders.testPackage2.UsingCounter", "1.0")); assertFalse(cl1.getClassLoader().equals(ClassLoader.getSystemClassLoader())); assertFalse(cl2.getClassLoader().equals(ClassLoader.getSystemClassLoader())); assertSame(cl1, cl2); }