target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@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 profi... | @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); } | 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); } } | 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); } } | 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(BarSe... | 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(BarSe... |
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(50), numOf(45))); assertFalse(criterion.betterThan(numOf(45), numOf(50))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } | ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | 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, Tr... | 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, Tr... |
@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.is... | @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(highestVa... | 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() && !highestV... | 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() && !highestV... | 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() && !highestV... | 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() && !highestV... |
@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 = getCrite... | @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); } | 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); } } | 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); } } | 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... | 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... |
@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 = getCriterio... | @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); } | 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); } } | 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); } } | 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... | 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... |
@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... | @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); } | 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); } } | 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); } } | 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... | 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... |
@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))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } | TotalLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | TotalLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | 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);... | 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);... |
@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 = getCriter... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } | 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 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); } | 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 calcul... | 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 calcul... |
@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)), va... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } | 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 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); } | 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 calcul... | 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 calcul... |
@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(... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } | 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 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); } | 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 calcul... | 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 calcul... |
@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())); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } | 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 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); } | 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 calcul... | 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 calcul... |
@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)); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } | 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 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); } | 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 calcul... | 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 calcul... |
@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))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } | ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ValueAtRiskCriterion(Double confidence); } | 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... | 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... |
@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)); asser... | @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.isLessThan... | 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 =... | 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 =... | 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 =... | 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 =... |
@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())); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | 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... | 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... |
@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 = getCriter... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | 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... | 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... |
@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)); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } } | 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... | 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... |
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } } | NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } } | 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... | 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... |
@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 = getCrite... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } | 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); } } | 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); } } | 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, Trading... | 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, Trading... |
@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 = getCriterio... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } | 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); } } | 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); } } | 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, Trading... | 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, Trading... |
@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... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } | 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); } } | 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); } } | 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, Trading... | 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, Trading... |
@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())); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } | 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); } } | 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); } } | 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, Trading... | 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, Trading... |
@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(... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } | 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); } } | 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); } } | 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, Trading... | 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, Trading... |
@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))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } | TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | 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... | 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... |
@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)); } | @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isGreaterThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } | 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 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 thresh... | 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 thresh... | 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 thresh... |
@Test public void externalData() throws Exception { BarSeries xlsSeries = xls.getSeries(); TradingRecord xlsTradingRecord = xls.getTradingRecord(); Num value; value = getCriterion(1000d, 0.005, 0.2).calculate(xlsSeries, xlsTradingRecord); assertNumEquals(xls.getFinalCriterionValue(1000d, 0.005, 0.2).doubleValue(), valu... | @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... |
@Test public void dummyData() { MockBarSeries series = new MockBarSeries(numFunction, 100, 150, 200, 100, 50, 100); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; tradingRecord.operate(0); tradingRecord.operate(1); criterion = getCriterion(1000d, 0.005, 0.2).calculate(series, tradingRecord); asse... | @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... |
@Test public void fixedCost() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; tradingRecord.operate(0); tradingRecord.operate(1); criterion = getCriterion(1000d, 0d, 1.3d).calculate(series, tradingRecord); assert... | @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... |
@Test public void fixedCostWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); Trade trade = new Trade(); Num criterion; criterion = getCriterion(1000d, 0d, 0.75d).calculate(series, trade); assertNumEquals(0d, criterion); trade.operate(1); criterion = getCriterion(1000d, 0d... | @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, doub... |
@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))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } } | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, d... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, d... | LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, d... |
@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())); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@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)); assertN... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@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... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@Test public void calculateWithNullSeriesSizeShouldReturn0() { MockBarSeries series = new MockBarSeries(numFunction, new double[] {}); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); } | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@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), ... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@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)); a... | @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... | 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 = ... | 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 = ... | 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 = ... | 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 = ... |
@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, serie... | @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } } | 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 tradingRecor... | 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 tradingRecor... |
@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))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } } | MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } } | 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 trad... | 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 trad... |
@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.s... | @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); } | 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); } } | 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); } } | 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 serie... | 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 serie... |
@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.sell... | @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); } | 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); } } | 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); } } | 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 serie... | 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 serie... |
@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)), O... | @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); } | 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); } } | 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); } } | 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 serie... | 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 serie... |
@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)), Orde... | @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); } | 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); } } | 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); } } | 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 serie... | 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 serie... |
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(5000), numOf(4500))); assertFalse(criterion.betterThan(numOf(4500), numOf(5000))); } | @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } | ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } } | 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)... | 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)... |
@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,... | public Num calculate(Trade trade) { return calculate(trade, 0); } | ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } } | ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } ZeroCostModel(); } | 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); } | 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); } |
@Test public void calculatePerPrice() { ZeroCostModel model = new ZeroCostModel(); Num cost = model.calculate(DoubleNum.valueOf(100), DoubleNum.valueOf(1)); assertNumEquals(cost, DoubleNum.valueOf(0)); } | public Num calculate(Trade trade) { return calculate(trade, 0); } | ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } } | ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } ZeroCostModel(); } | 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); } | 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); } |
@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); } | public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } | ZeroCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } } | ZeroCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } ZeroCostModel(); } | 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 ... | 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 ... |
@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));... | @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... | 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 = ... | 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 = ... | 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 = ... | 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 = ... |
@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); } | public Num calculate(Num price, Num amount) { return price.numOf(0); } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); } | 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); } | 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); } |
@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... | public Num calculate(Num price, Num amount) { return price.numOf(0); } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); } | 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); } | 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); } |
@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 costsFromTrad... | public Num calculate(Num price, Num amount) { return price.numOf(0); } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); } | 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); } | 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); } |
@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(tr... | public Num calculate(Num price, Num amount) { return price.numOf(0); } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } } | LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); } | 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); } | 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); } |
@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); bool... | public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearBorrowingCostModel) otherModel).feePerPeriod == this.feePerPeriod; } return equality; } | 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 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 feePerPe... | 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 feePerPe... | 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 feePerPe... |
@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); } | public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); } | 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... | 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... |
@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, ne... | public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); } | 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... | 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... |
@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, n... | public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); } | 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... | 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... |
@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, Do... | public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } } | LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); } | 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... | 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... |
@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(modelSameFe... | public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearTransactionCostModel) otherModel).feePerTrade == this.feePerTrade; } return equality; } | 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 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 feeP... | 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 feeP... | 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 feeP... |
@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... | @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 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 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); } | 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 boo... | 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 boo... |
@Test public void whenNewShouldNotExit() { assertFalse(newTrade.isOpened()); } | public boolean isOpened() { return (entry != null) && (exit == null); } | Trade implements Serializable { public boolean isOpened() { return (entry != null) && (exit == null); } } | 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 transact... | 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 transact... | 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 transact... |
@Test(expected = IllegalStateException.class) public void whenExitIndexIsLessThanEntryIndexShouldThrowException() { newTrade.operate(3); newTrade.operate(1); } | public Order operate(int index) { return operate(index, NaN, NaN); } | Trade implements Serializable { public Order operate(int index) { return operate(index, NaN, NaN); } } | 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 transaction... | 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 transaction... | 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 transaction... |
@Test public void overrideToString() { assertEquals(trEquals1.toString(), trEquals2.toString()); assertNotEquals(trEquals1.toString(), trNotEquals1.toString()); assertNotEquals(trEquals1.toString(), trNotEquals2.toString()); } | @Override public String toString() { return "Entry: " + entry + " exit: " + exit; } | Trade implements Serializable { @Override public String toString() { return "Entry: " + entry + " exit: " + exit; } } | 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, CostMo... | 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, CostMo... | 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, CostMo... |
@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()); assert... | public Order operate(int index) { return operate(index, NaN, NaN); } | Trade implements Serializable { public Order operate(int index) { return operate(index, NaN, NaN); } } | 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 transaction... | 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 transaction... | 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 transaction... |
@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(... | public Order operate(int index) { return operate(index, NaN, NaN); } | Trade implements Serializable { public Order operate(int index) { return operate(index, NaN, NaN); } } | 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 transaction... | 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 transaction... | 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 transaction... |
@Test public void precisionNumTest() { init(); test(); } | private PrecisionNum(String val) { delegate = new BigDecimal(val); int precision = Math.max(delegate.precision(), DEFAULT_PRECISION); mathContext = new MathContext(precision, RoundingMode.HALF_UP); } | 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); } } | 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); priva... | 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); priva... | 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); priva... |
@Test(expected = NumberFormatException.class) public void testValueOfForFloatNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Float.NaN); } | public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } | PrecisionNum implements Num { public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } } | 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 Precision... | 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 Precision... | 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 Precision... |
@Test(expected = NumberFormatException.class) public void testValueOfForDoubleNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Double.NaN); } | public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } | PrecisionNum implements Num { public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } } | 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 Precision... | 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 Precision... | 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 Precision... |
@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, 4... | @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } | 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 implements BarSeriesAggregator { @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } BaseBarSeriesAggregator(BarAggre... | 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(BarAggre... | 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(BarAggre... |
@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, 3... | @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } | 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 implements BarSeriesAggregator { @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } BaseBarSeriesAggregator(BarAggre... | 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(BarAggre... | 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(BarAggre... |
@Test public void isSatisfied() { assertTrue(rule.isSatisfied(10)); assertFalse(rule.isSatisfied(11)); assertFalse(rule.isSatisfied(12)); assertFalse(rule.isSatisfied(13)); assertFalse(rule.isSatisfied(14)); } | @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 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 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 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 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... |
@Test public void upscaledTo5DayBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(5), true); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(3, bars.size()); final Bar bar1 = bars.get(0); final Num num1 = bar1.getOpenPrice(); TestUtils.assertNum... | @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() % actualDur.getSeconds() == 0; if (!isMultiplicati... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... |
@Test public void upscaledTo10DayBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(10), true); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(1, bars.size()); final Bar bar1 = bars.get(0); final Num num1 = bar1.getOpenPrice(); TestUtils.assertN... | @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() % actualDur.getSeconds() == 0; if (!isMultiplicati... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... |
@Test public void upscaledTo10DayBarsNotOnlyFinalBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(10), false); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(2, bars.size()); } | @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() % actualDur.getSeconds() == 0; if (!isMultiplicati... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... | DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() %... |
@Test public void test() { StrategyExecutionLogging.main(null); } | 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(); } | 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); unloadLogge... | 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); unloadLogge... | 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); unloadLogge... | 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); unloadLogge... |
@Test public void test() { RSI2Strategy.main(null); } | 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: " ... | 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 t... | 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 t... | 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 t... | 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 t... |
@Test public void test() { GlobalExtremaStrategy.main(null); } | 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: " ... | 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 tra... | 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 tra... | 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 tra... | 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 tra... |
@Test public void test() { CCICorrectionStrategy.main(null); } | 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: " ... | 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 tra... | 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 tra... | 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 tra... | 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 tra... |
@Test public void test() { MovingMomentumStrategy.main(null); } | 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: " ... | 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 tr... | 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 tr... | 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 tr... | 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 tr... |
@Test public void test() { Quickstart.main(null); } | 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(firstC... | 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.p... | 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.p... | 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.p... | 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.p... |
@Test public void test() { BuildBarSeries.main(null); } | @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()); ... | 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).getClosePri... | 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).getClosePri... | 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).getClosePri... | 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).getClosePri... |
@Test public void isSatisfiedInReverseOrder() { assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); } | @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 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 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 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 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... |
@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.... | @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 / (do... | 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 ... | 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 ... | 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 ... | 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 ... |
@Test public void test() { WalkForward.main(null); } | 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 (... | 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 TotalProfitCrit... | 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 TotalProfitCrit... | 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 TotalProfitCrit... | 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 TotalProfitCrit... |
@Test public void test() { CandlestickChart.main(null); } | 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... | 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",... | 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",... | 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",... | 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",... |
@Test public void test() { IndicatorsToChart.main(null); } | 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); BollingerBandsMiddleI... | 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); B... | 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); B... | 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); B... | 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); B... |
@Test public void test() { IndicatorsToCsv.main(null); } | 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); SMAInd... | IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicat... | IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicat... | IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicat... | IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicat... |
@Test public void test() { StrategyAnalysis.main(null); } | 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 =... | 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); TotalProfitCrit... | 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); TotalProfitCrit... | 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); TotalProfitCrit... | 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); TotalProfitCrit... |
@Test public void test() { TradeCost.main(null); } | 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 borrowingCo... | 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... | 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... | 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... | 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... |
@Test public void test() { CashFlowToChart.main(null); } | 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(s... | 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 cashFlo... | 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 cashFlo... | 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 cashFlo... | 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 cashFlo... |
@Test public void test() { BuyAndSellSignalsToChart.main(null); } | 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... | 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... | 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... | 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... | 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... |
@Test public void test() { CompareNumTypes.main(null); } | 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(Pr... | 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")... | 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")... | 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")... | 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")... |
@Test public void test() throws InterruptedException { TradingBotOnMovingBarSeries.main(null); } | 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("*****... | TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecor... | TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecor... | TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecor... | TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecor... |
@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)); } | @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 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 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 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 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... |
@Test public void test() { CsvTradesLoader.main(null); } | 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: " + serie... | 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" + "\... | 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" + "\... | 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" + "\... | 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" + "\... |
@Test public void test() { CsvBarsLoader.main(null); } | 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.... | 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" + "\tVol... | 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" + "\tVol... | 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" + "\tVol... | 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" + "\tVol... |
@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)); } | @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 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 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 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 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... |
@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)); assertFa... | @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 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 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 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 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... |
@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... | @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... | 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 t... | 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 t... | 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 t... | 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 t... |
@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(cl... | @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... | 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 t... | 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 t... | 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 t... | 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 t... |
@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(satisfie... | @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 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 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); } | 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 bo... | 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 bo... |
@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.is... | @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 / (doubl... | 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 +=... | 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 +=... | 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 +=... | 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 +=... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.