ta4j

https://github.com/ta4j/ta4j-wiki
Admin
Ta4j is a Java library for technical analysis of financial time series, providing indicators and...
Tokens:103,967
Snippets:1,266
Trust Score:5.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Run ta4j Quickstart Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Examples-Expected-Outputs.md

Execute the Quickstart example to see staged walkthrough sections and a trade metrics summary. In GUI mode, a chart window will open.

```bash
mvn -pl ta4j-examples exec:java -Dexec.mainClass=ta4jexamples.Quickstart
```

--------------------------------

### Run ta4j TradingRecordParityBacktest Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Examples-Expected-Outputs.md

Execute the TradingRecordParityBacktest example to compare execution models and verify record-parity checks.

```bash
mvn -pl ta4j-examples exec:java -Dexec.mainClass=ta4jexamples.backtesting.TradingRecordParityBacktest
```

--------------------------------

### Run ta4j Examples Tests

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Getting-started.md

Executes tests for the ta4j examples module. This helps verify your environment setup.

```bash
mvn -pl ta4j-examples test
```

--------------------------------

### Execute Elliott Wave Preset Demos

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Command-line examples for running pre-configured Elliott Wave analysis on various assets.

```bash
# Analyze ossified Bitcoin with default settings
java ta4jexamples.analysis.elliottwave.ElliottWavePresetDemo ossified btc

# Analyze ossified Ethereum
java ta4jexamples.analysis.elliottwave.ElliottWavePresetDemo ossified eth

# Analyze ossified S&P 500
java ta4jexamples.analysis.elliottwave.ElliottWavePresetDemo ossified sp500

# Custom live-style analysis with command-line arguments
java ta4jexamples.analysis.elliottwave.ElliottWavePresetDemo live Coinbase BTC-USD PT1D 1825 PRIMARY
```

--------------------------------

### Run Rolling Conformal Forecast Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Forecast-Projection-Models.md

Commands to build and execute the RollingConformalForecastExample using Maven.

```bash
./mvnw -pl ta4j-examples -am install
./mvnw -pl ta4j-examples exec:java \
  -Dexec.mainClass=ta4jexamples.analysis.forecast.RollingConformalForecastExample
```

--------------------------------

### Example Usage: Coinbase Backtest

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Illustrates backtesting with data fetched from Coinbase. This is useful for understanding cryptocurrency data integration and strategy execution.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.BaseBarSeries;

import java.time.LocalDate;
import java.time.Duration;

public class CoinbaseBacktest {

    public static void main(String[] args) {
        // 1. Building a bar series from Coinbase
        BarSeries series = new BaseBarSeries();
        // For example, we will use the "2018-01-01" to "2018-01-31" interval
        // For more details, see the "Data Sources" page
        series.addBars(CoinbaseData.getBars(series, "BTC-USD", "1DAY", LocalDate.of(2018, 1, 1), LocalDate.of(2018, 1, 31)));

        // 2. Strategy design with TA-Lib
        // Close price indicator
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);

        // SMA indicators
        SMAIndicator shortSma = new SMAIndicator(closePrice, 5);
        SMAIndicator longSma = new SMAIndicator(closePrice, 10);

        // Strategy rules
        // Buy rule: close price crosses above the long SMA
        Strategy buyStrategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(buyStrategy);
        System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount());

        // 4. Analysis of the strategy results
        // TODO
    }
}

class CoinbaseData {
    public static java.util.List<org.ta4j.core.Bar> getBars(BarSeries barSeries, String symbol, String interval, LocalDate start, LocalDate end) {
        // This is a placeholder for actual data fetching logic.
        // In a real application, you would use a library like "ta4j-core"'s Coinbase data provider
        // or another financial data API to fetch historical OHLCV data.
        // For demonstration purposes, we'll return an empty list.
        System.out.println("Fetching data for " + symbol + " interval " + interval + " from " + start + " to " + end);
        return java.util.Collections.emptyList();
    }
}
```

--------------------------------

### Example Usage: Yahoo Finance Backtest

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Demonstrates how to perform a backtest using data from Yahoo Finance. This example is useful for understanding data ingestion and backtesting execution.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.BaseBarSeries;

import java.time.LocalDate;
import java.time.Duration;

public class YahooFinanceBacktest {

    public static void main(String[] args) {
        // 1. Building a bar series from Yahoo Finance
        BarSeries series = new BaseBarSeries();
        // For example, we will use the "2018-01-01" to "2018-01-31" interval
        // For more details, see the "Data Sources" page
        series.addBars(YahooFinanceData.getBars(series, "AAPL", LocalDate.of(2018, 1, 1), LocalDate.of(2018, 1, 31)));

        // 2. Strategy design with TA-Lib
        // Close price indicator
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);

        // SMA indicators
        SMAIndicator shortSma = new SMAIndicator(closePrice, 5);
        SMAIndicator longSma = new SMAIndicator(closePrice, 10);

        // Strategy rules
        // Buy rule: close price crosses above the long SMA
        Strategy buyStrategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(buyStrategy);
        System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount());

        // 4. Analysis of the strategy results
        // TODO
    }
}

class YahooFinanceData {
    public static java.util.List<org.ta4j.core.Bar> getBars(BarSeries barSeries, String symbol, LocalDate start, LocalDate end) {
        // This is a placeholder for actual data fetching logic.
        // In a real application, you would use a library like "ta4j-core"'s YahooFinance data provider
        // or another financial data API to fetch historical OHLCV data.
        // For demonstration purposes, we'll return an empty list.
        System.out.println("Fetching data for " + symbol + " from " + start + " to " + end);
        return java.util.Collections.emptyList();
    }
}
```

--------------------------------

### Trade Fill Recording Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Demonstrates how to record trade fills, separating signal decisions from fill recording. This is essential for realistic backtesting and live trading.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseBarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;
import org.ta4j.core.Trade;

public class TradeFillRecordingExample {

    public static void main(String[] args) {
        // 1. Building a bar series
        BarSeries series = new BaseBarSeries();
        series.addBar(10, 12, 9, 11, 100);
        series.addBar(11, 13, 10, 12, 120);
        series.addBar(12, 14, 11, 13, 110);
        series.addBar(13, 15, 12, 14, 130);
        series.addBar(14, 16, 13, 15, 140);
        series.addBar(15, 17, 14, 16, 150);

        // 2. Strategy design
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
        SMAIndicator shortSma = new SMAIndicator(closePrice, 2);
        SMAIndicator longSma = new SMAIndicator(closePrice, 4);
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(strategy);

        // 4. Recording trade fills
        // In a real scenario, you would iterate through the tradingRecord and record fills
        // based on broker confirmations or simulated execution logic.
        System.out.println("Number of trades: " + tradingRecord.getTradeCount());
        for (Trade trade : tradingRecord.getTrades()) {
            System.out.println("Trade: " + trade.getEntry().getIndex() + " to " + trade.getExit().getIndex());
            // Here you would add logic to record the fill details (price, quantity, timestamp, etc.)
        }
    }
}
```

--------------------------------

### Direct Push Override Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/completed-features/RELEASE_PROCESS_PRD.md

Demonstrates how to bypass the standard Pull Request creation process and publish a release directly. This is intended for emergency use cases.

```bash
RELEASE_DIRECT_PUSH=true
```

--------------------------------

### Example Entry Logic (Accumulation Continuation)

Source: https://github.com/ta4j/ta4j-wiki/blob/master/VWAP-Support-Resistance-and-Wyckoff.md

Implement entry logic for a long position during accumulation phases, checking for agreement between high-level and low-level Wyckoff indicators, price position relative to VWAP and support, and Z-score thresholds.

```java
int i = series.getEndIndex();
Num price = close.getValue(i);
WyckoffPhase phase = wyckoff.getValue(i);           // low-level indicator path
WyckoffPhase cyclePhase = wyckoffFacade.phase(i);   // high-level facade path
Num cycleRangeLow = wyckoffFacade.tradingRangeLow(i);

boolean inAccumulationAdvance = phase.cycleType() == WyckoffCycleType.ACCUMULATION
        && (phase.phaseType() == WyckoffPhaseType.PHASE_D || phase.phaseType() == WyckoffPhaseType.PHASE_E)
        && phase.confidence() >= 0.75;
boolean cycleAgrees = cyclePhase.cycleType() == WyckoffCycleType.ACCUMULATION;

boolean aboveValue = price.isGreaterThan(vwap.getValue(i));
boolean notOverextended = zScore.getValue(i).isLessThan(num.numOf("2.0"));
boolean nearSupport = price.minus(support.getValue(i)).abs().isLessThanOrEqual(num.numOf("0.5"));
boolean nearCycleRangeLow = price.minus(cycleRangeLow).abs().isLessThanOrEqual(num.numOf("0.5"));

if (inAccumulationAdvance && cycleAgrees && aboveValue && notOverextended && nearSupport && nearCycleRangeLow) {
    // candidate long condition
}
```

--------------------------------

### Backtest Performance Tuning Harness Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Provides a harness for tuning backtest performance. This is useful for optimizing the execution speed of backtesting processes.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseBarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;

public class BacktestPerformanceTuningHarness {

    public static void main(String[] args) {
        // 1. Building a bar series
        BarSeries series = new BaseBarSeries();
        // Add a large amount of sample data for performance testing
        for (int i = 0; i < 10000; i++) {
            series.addBar(i, i + 2, i, i + 1, 100);
        }

        // 2. Strategy design
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
        SMAIndicator shortSma = new SMAIndicator(closePrice, 5);
        SMAIndicator longSma = new SMAIndicator(closePrice, 10);
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        long startTime = System.nanoTime();
        TradingRecord tradingRecord = seriesManager.run(strategy);
        long endTime = System.nanoTime();

        // 4. Performance measurement
        System.out.println("Backtest completed in " + (endTime - startTime) / 1_000_000 + " ms");
        System.out.println("Number of trades: " + tradingRecord.getTradeCount());
    }
}
```

--------------------------------

### Initialize Single-Threaded Market and Trading State

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Live-trading.md

Use this for single-threaded setups to initialize a BaseBarSeries and a BaseTradingRecord. Ensure the strategy's starting type and execution match policy are correctly set.

```java
BarSeries series = new BaseBarSeriesBuilder()
        .withName("eth-usd-live")
        .build();

BaseTradingRecord tradingRecord = new BaseTradingRecord(
        strategy.getStartingType(),
        ExecutionMatchPolicy.FIFO,
        RecordedTradeCostModel.INSTANCE,
        new ZeroCostModel(),
        null,
        null);
```

--------------------------------

### Install ta4j Core Module

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Getting-started.md

Installs the ta4j-core module locally. Use this if you need the latest master APIs not yet available on Maven Central.

```bash
mvn -pl ta4j-core -am install
```

--------------------------------

### Simple Moving Average Range Backtest Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Performs a backtest using a Simple Moving Average (SMA) crossover strategy. This example focuses on range-based trading conditions.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;
import org.ta4j.core.BaseBarSeries;

public class SimpleMovingAverageRangeBacktest {

    public static void main(String[] args) {
        // 1. Building a bar series
        BarSeries series = new BaseBarSeries();
        // Add some sample data (replace with actual data loading)
        series.addBar(10, 12, 9, 11, 100);
        series.addBar(11, 13, 10, 12, 120);
        series.addBar(12, 14, 11, 13, 110);
        series.addBar(13, 15, 12, 14, 130);
        series.addBar(14, 16, 13, 15, 140);
        series.addBar(15, 17, 14, 16, 150);

        // 2. Strategy design
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
        SMAIndicator shortSma = new SMAIndicator(closePrice, 2);
        SMAIndicator longSma = new SMAIndicator(closePrice, 4);
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(strategy);

        // 4. Analysis of the strategy results
        System.out.println("Number of trades: " + tradingRecord.getTradeCount());
        // Further analysis can be performed here.
    }
}
```

--------------------------------

### Build and Add a Bar to a Live Series

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Bar-series-and-bars.md

Initializes a new BaseBarSeries and adds the first bar with specified time, price, and volume data. Useful for starting a live data feed.

```java
BarSeries liveSeries = new BaseBarSeriesBuilder()
        .withName("eth_usd_live")
        .build();

Bar latest = liveSeries.barBuilder()
        .timePeriod(Duration.ofMinutes(1))
        .endTime(Instant.now())
        .openPrice(100.0)
        .highPrice(101.0)
        .lowPrice(99.5)
        .closePrice(100.7)
        .volume(42)
        .build();

liveSeries.addBar(latest);
```

--------------------------------

### Risk Gating Rules Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Stop-Loss-and-Stop-Gain-Rules.md

Demonstrates the usage of various risk gating rules including RiskRewardRatioRule, OverOrEqualIndicatorRule, UnderOrEqualIndicatorRule, and OrWithThresholdRule to build a complex entry rule.

```java
Rule rrGate = new RiskRewardRatioRule(close, stopPrice, targetPrice, true, 2.0);
Rule inclusiveState = new OverOrEqualIndicatorRule(rsi, 50);
Rule inclusiveOversold = new UnderOrEqualIndicatorRule(rsi, 30);
Rule delayedConfirm = new OrWithThresholdRule(macdCrossUp, breakoutRule, 3);

Rule entryRule = rrGate.and(inclusiveState).and(inclusiveOversold.negation()).and(delayedConfirm);
```

--------------------------------

### Net Momentum Strategy Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Implements a Net Momentum strategy. This strategy combines multiple indicators to determine entry and exit points.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;

public class NetMomentumStrategy {

    public static Strategy buildStrategy(BarSeries series) {
        // We need to define the trading session timeframe
        int shortSmaTimeFrame = 5;
        int longSmaTimeFrame = 10;

        // Close price indicator
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);

        // SMA indicators
        SMAIndicator shortSma = new SMAIndicator(closePrice, shortSmaTimeFrame);
        SMAIndicator longSma = new SMAIndicator(closePrice, longSmaTimeFrame);

        // Strategy rules
        // Buy rule: short SMA crosses above long SMA
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // Set unstable bars for the strategy
        strategy.setUnstableBars(longSmaTimeFrame);

        return strategy;
    }
}
```

--------------------------------

### Wiring Exit Rules with Stop-Loss and Stop-Gain

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Stop-Loss-and-Stop-Gain-Rules.md

This example demonstrates how to combine different stop-loss and stop-gain rules with a signal-based exit rule to create a comprehensive exit strategy. It includes an ATR-based trailing stop loss, an ATR-based trailing stop gain, and a fixed amount stop loss as a fail-safe. The strategy is then constructed using these exit rules.

```java
ClosePriceIndicator close = new ClosePriceIndicator(series);
ATRIndicator atr = new ATRIndicator(series, 14);

Rule riskExit = new AverageTrueRangeTrailingStopLossRule(close, atr, 2.0)
        .or(new AverageTrueRangeTrailingStopGainRule(close, atr, 3.0))
        .or(new StopLossRule(close, series.numFactory().numOf(1.5))); // hard fail-safe

Rule signalExit = new CrossedDownIndicatorRule(fast, slow);
Rule exitRule = signalExit.or(riskExit);

Strategy strategy = new BaseStrategy(entryRule, exitRule);
```

--------------------------------

### Concurrent Usage Example for ConcurrentBarSeries

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Bar-series-and-bars.md

Demonstrates how multiple threads can safely interact with a ConcurrentBarSeries for simultaneous trade ingestion, strategy evaluation, and indicator calculation.

```java
// Thread 1: Ingest trades from WebSocket
executorService.submit(() -> {
    while (running) {
        Trade trade = websocket.receiveTrade();
        concurrentSeries.ingestTrade(trade.getTime(), trade.getVolume(), trade.getPrice());
    }
});

// Thread 2: Evaluate strategy
executorService.submit(() -> {
    while (running) {
        int endIndex = concurrentSeries.getEndIndex();
        if (strategy.shouldEnter(endIndex, tradingRecord)) {
            // Execute trade...
        }
    }
});

// Thread 3: Calculate indicators
executorService.submit(() -> {
    while (running) {
        int endIndex = concurrentSeries.getEndIndex();
        Num rsiValue = rsiIndicator.getValue(endIndex);
        // Use indicator value...
    }
});
```

--------------------------------

### RSI2 Strategy Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Implements the RSI(2) trading strategy. This is a common strategy for demonstrating rule composition and indicator usage.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.indicators.RSIIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;

public class RSI2Strategy {

    public static Strategy buildStrategy(BarSeries series) {
        // We need to define the trading session timeframe
        // For example, for a daily series, we can use 14 days
        int timeFrame = 14;

        // Close price indicator
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);

        // RSI indicator
        RSIIndicator rsi = new RSIIndicator(closePrice, timeFrame);

        // Strategy rules
        // Buy rule: RSI crosses above 30
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(rsi, 30), new UnderIndicatorRule(rsi, 70));

        // Set unstable bars for the strategy
        // This is important for indicators that need a certain amount of data to be calculated correctly
        strategy.setUnstableBars(timeFrame);

        return strategy;
    }
}
```

--------------------------------

### Run Trend Line and Swing Point Analysis

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Highs-and-Lows.md

Executes the trend line and swing point analysis example from the ta4j source checkout using Maven.

```bash
./mvnw -pl ta4j-examples -am install
./mvnw -pl ta4j-examples \
  -Dexec.mainClass=ta4jexamples.analysis.TrendLineAndSwingPointAnalysis \
  -Dexec.args="--no-display --no-save" \
  exec:java
```

--------------------------------

### Trading Bot on Moving Bar Series Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Illustrates a trading bot operating on a moving bar series. This is relevant for live trading scenarios where new data arrives continuously.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseBarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;

public class TradingBotOnMovingBarSeries {

    public static void main(String[] args) {
        // 1. Building a moving bar series
        BarSeries series = new BaseBarSeries();

        // Simulate new bars arriving over time
        for (int i = 0; i < 100; i++) {
            series.addBar(i, i + 2, i, i + 1, 100);
            // In a real bot, you would add logic here to process the new bar
            // and potentially make trading decisions.
            processNewBar(series);
        }
    }

    private static void processNewBar(BarSeries series) {
        // 2. Strategy design (example: SMA crossover)
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
        SMAIndicator shortSma = new SMAIndicator(closePrice, 5);
        SMAIndicator longSma = new SMAIndicator(closePrice, 10);
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Running the strategy on the current series state
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(strategy);

        // 4. Bot logic: making trading decisions based on the trading record
        if (!tradingRecord.getTrades().isEmpty()) {
            Trade lastTrade = tradingRecord.getLastTrade();
            if (lastTrade.isBuy() && !series.isTradingEnabled()) {
                System.out.println("BUY signal at bar " + lastTrade.getEntry().getIndex());
                // Execute buy order
                series.setTradingEnabled(true);
            } else if (lastTrade.isSell() && series.isTradingEnabled()) {
                System.out.println("SELL signal at bar " + lastTrade.getExit().getIndex());
                // Execute sell order
                series.setTradingEnabled(false);
            }
        }
    }
}
```

--------------------------------

### Combine Elliott Wave with RSI

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Integrate Elliott Wave phase detection with RSI indicators to identify potential entry and exit setups.

```java
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 5, ElliottDegree.INTERMEDIATE);
RSIIndicator rsi = new RSIIndicator(new ClosePriceIndicator(series), 14);

int index = series.getEndIndex();
Optional<ElliottScenario> baseCase = facade.primaryScenario(index);
Num rsiValue = rsi.getValue(index);

if (baseCase.isPresent()) {
    ElliottScenario scenario = baseCase.get();
    
    // Wave 2 + oversold RSI = potential wave 3 entry
    if (scenario.currentPhase() == ElliottPhase.WAVE2 
            && rsiValue.isLessThan(series.numFactory().numOf(30))) {
        System.out.println("Wave 3 entry setup with RSI confirmation");
    }
    
    // Wave 5 + overbought RSI + bearish divergence = potential exit
    if (scenario.currentPhase() == ElliottPhase.WAVE5
            && rsiValue.isGreaterThan(series.numFactory().numOf(70))) {
        System.out.println("Potential wave 5 exhaustion");
    }
}
```

--------------------------------

### Initialize Elliott Wave Facade and Retrieve Scenarios

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Demonstrates how to initialize the ElliottWaveFacade and extract base cases, consensus, and alternative scenarios.

```java
// Create facade
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 5, ElliottDegree.INTERMEDIATE);
int index = series.getEndIndex();

// Get base case interpretation with confidence
Optional<ElliottScenario> baseCase = facade.primaryScenario(index);
if (baseCase.isPresent()) {
    ElliottScenario bc = baseCase.get();
    System.out.println("Phase: " + p.currentPhase());
    System.out.println("Confidence: " + String.format("%.1f%%", p.confidence().asPercentage()));
    System.out.println("Invalidation: " + p.invalidationPrice());
    System.out.println("Target: " + p.primaryTarget());
}

// Check for consensus
if (facade.hasScenarioConsensus(index)) {
    System.out.println("Strong consensus: " + facade.scenarioConsensus(index));
}

// Get alternatives
List<ElliottScenario> alts = facade.alternativeScenarios(index);
System.out.println("Alternative counts: " + alts.size());
```

--------------------------------

### Example Coinbase JSON Format

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Data-Sources.md

An example of the JSON structure expected for Coinbase API response format, containing an array of candle data with start time, low, high, open, close, and volume.

```json
{
  "candles": [
    {
      "start": "2023-01-01T00:00:00Z",
      "low": "149.50",
      "high": "152.50",
      "open": "150.00",
      "close": "151.25",
      "volume": "1000000"
    },
    {
      "start": "2023-01-02T00:00:00Z",
      "low": "150.75",
      "high": "153.00",
      "open": "151.25",
      "close": "152.00",
      "volume": "1200000"
    }
  ]
}
```

--------------------------------

### Yahoo Finance Data Source with Caching

Source: https://github.com/ta4j/ta4j-wiki/blob/master/architecture/proposed/TODO-bar-series-datasource-refactoring.md

Example of composing a YahooFinanceHttpBarSeriesDataSource using a CachedHttpDataRetrievalClient. Ensure caching is enabled by setting the boolean parameter to true. This setup is useful when dealing with frequently accessed financial data where performance is critical.

```java
HttpDataRetrievalClient httpClient = new HttpDataRetrievalClient(httpClientWrapper);
CachedHttpDataRetrievalClient cachedClient = new CachedHttpDataRetrievalClient(
    httpClient, 
    Paths.get("temp/responses"),
    true  // caching enabled
);
YahooFinanceJsonMapper mapper = new YahooFinanceJsonMapper();

// Compose data source
YahooFinanceHttpBarSeriesDataSource yahoo = new YahooFinanceHttpBarSeriesDataSource(
    cachedClient, 
    mapper
);

// Use as before
BarSeries series = yahoo.loadSeries("AAPL", Duration.ofDays(1), start, end);
```

--------------------------------

### Run ElliottWaveIndicatorSuiteDemo via CLI

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Execute the main suite demo from the command line using either default datasets or external data sources.

```bash
# Load the default ossified BTC-USD dataset
java ta4jexamples.analysis.elliottwave.ElliottWaveIndicatorSuiteDemo

# Load from an external data source
java ta4jexamples.analysis.elliottwave.ElliottWaveIndicatorSuiteDemo [dataSource] [ticker] [barDuration] [startEpoch] [endEpoch]
java ta4jexamples.analysis.elliottwave.ElliottWaveIndicatorSuiteDemo [dataSource] [ticker] [barDuration] [degree] [startEpoch] [endEpoch]
```

--------------------------------

### RSI Indicator Test Class Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/XLS-Testing.md

Example of a JUnit test class for the RSI indicator, extending the generic IndicatorTest class.

```java
public class RSIIndicatorTest extends IndicatorTest<Indicator<Decimal>, Decimal> {

    private ExternalIndicatorTest xls;

    public RSIIndicatorTest() {
        super((data, params) -> new RSIIndicator(data, (int) params[0]));
        xls = new XLSIndicatorTest(this.getClass(), "RSI.xls", 10);
    }
}
```

--------------------------------

### Instance Load for Unit Testing with Mock Client

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Data-Sources.md

Demonstrates creating an instance for loading data using a mocked HTTP client. This is essential for unit testing data loading logic without making actual network requests.

```java
// For unit testing with mock HTTP client
HttpClientWrapper mockClient = mock(HttpClientWrapper.class);
YahooFinanceHttpBarSeriesDataSource loader = new YahooFinanceHttpBarSeriesDataSource(mockClient);
BarSeries series = loader.loadSeriesInstance("AAPL", YahooFinanceInterval.DAY_1, start, end);
```

--------------------------------

### Java CriterionTest Class Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/XLS-Testing.md

An example of a criterion test class extending CriterionTest for XLS-based criterion unit tests. It initializes an ExternalCriterionTest object for data extraction and calculation.

```java
public class LinearTransactionCostCriterionTest extends CriterionTest {

    private ExternalCriterionTest xls;

    public LinearTransactionCostCriterionTest() throws Exception {
        super((params) -> new LinearTransactionCostCriterion((double) params[0], (double) params[1], (double) params[2]));
        xls = new XLSCriterionTest(this.getClass(), "LTC.xls", 16, 6);
    }
}
```

--------------------------------

### Example Bitstamp Trades CSV Format

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Data-Sources.md

An example of the CSV format for Bitstamp trades data, including a header row and columns for timestamp (Unix seconds), price, and volume.

```csv
timestamp,price,volume
1385337600,150.00,1.5
1385337610,150.25,2.0
1385337620,150.50,1.0
1385337630,150.75,3.5
```

--------------------------------

### Run ta4j TradeFillRecordingExample

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Examples-Expected-Outputs.md

Execute the TradeFillRecordingExample to observe streamed fill ingestion, grouped order ingestion, and lot-matching outcomes for different ExecutionMatchPolicy values.

```bash
mvn -pl ta4j-examples exec:java -Dexec.mainClass=ta4jexamples.backtesting.TradeFillRecordingExample
```

--------------------------------

### Automatic Axis Assignment Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Charting.md

This example demonstrates how ChartBuilder automatically assigns indicators to primary and secondary Y-axes. The RSI (0-100) is placed on the secondary axis, while the SMA (price range) is placed on the primary axis, alongside the series price data.

```java
RSIIndicator rsi = new RSIIndicator(closePrice, 14);
SMAIndicator sma = new SMAIndicator(closePrice, 50);

chartWorkflow.builder()
    .withSeries(series)  // Primary axis: price range
    .withIndicatorOverlay(sma)  // Primary axis: same range as price
    .withIndicatorOverlay(rsi)  // Secondary axis: 0-100 range
    .display();
```

--------------------------------

### Create a short-only strategy

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Trading-strategies.md

Defines a strategy specifically for short-selling by setting the starting trade type.

```java
Strategy shortOnly = new BaseStrategy("Short breakdown", shortEntryRule, shortExitRule, Trade.TradeType.SELL);
```

--------------------------------

### Build Elliott Wave Analyzer with Custom Components

Source: https://github.com/ta4j/ta4j-wiki/blob/master/architecture/proposed/ew-enhancements-part-2/TODO-ta4j-elliottwave-enhancements-part-2.md

Demonstrates how to construct an ElliottWaveAnalyzer by specifying custom detectors, compression profiles, scenario generators, and confidence models. This allows for fine-grained control over the analysis process.

```java
ElliottWaveAnalyzer analyzer = ElliottWaveAnalyzer.builder()
    .swingDetector(SwingDetectors.composite(
        SwingDetectors.fractal(5),
        SwingDetectors.adaptiveZigZag(adaptiveCfg)
    ))
    .swingCompression(CompressionProfiles.primaryDegree())
    .scenarioGenerator(ScenarioGenerators.defaultEnabled())
    .confidenceModel(ConfidenceProfiles.defaultByScenarioType())
    .build();

ElliottAnalysisResult result = analyzer.analyze(series);
ElliottScenario base = result.scenarios().base();
```

--------------------------------

### Add ta4j-examples Dependency

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Charting.md

Include the ta4j-examples module as a dependency to use charting functionalities in your project.

```xml
<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-examples</artifactId>
  <version>${USE_LATEST_VERSION}</version>
</dependency>
```

--------------------------------

### Get JFreeChart Object

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Charting.md

Obtain the JFreeChart object from the builder for further customization or display. Requires series and tradingRecordOverlay.

```java
JFreeChart chart = chartWorkflow.builder()
    .withSeries(series)
    .withTradingRecordOverlay(tradingRecord)
    .toChart();

// Further customize the chart if needed
chart.setTitle("Custom Title");
chartWorkflow.displayChart(chart);
```

--------------------------------

### Initialize ElliottWaveFacade with Factory Methods

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Shows various factory methods available for creating an ElliottWaveFacade based on different swing detection approaches.

```java
// Fractal-based with symmetric window (5 bars before and after pivot)
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 5, ElliottDegree.INTERMEDIATE);

// Fractal-based with asymmetric window
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 3, 5, ElliottDegree.INTERMEDIATE);

// ZigZag-based with ATR(14) reversal threshold
ElliottWaveFacade facade = ElliottWaveFacade.zigZag(series, ElliottDegree.INTERMEDIATE);

// From custom swing indicator
ElliottWaveFacade facade = ElliottWaveFacade.from(customSwingIndicator, closePriceIndicator);
```

--------------------------------

### Trade Cost Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Calculates the cost associated with trades, including commissions and slippage. This is important for realistic performance analysis.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseBarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.TimeSeriesManager;
import org.ta4j.core.TradingRecord;
import org.ta4j.core.indicators.SMAIndicator;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;
import org.ta4j.core.analysis.criteria.TotalProfitCriterion;
import org.ta4j.core.analysis.criteria.AverageProfitCriterion;
import org.ta4j.core.analysis.criteria.AverageEdgeCriterion;
import org.ta4j.core.analysis.criteria.AverageTransactionCostCriterion;

public class TradeCost {

    public static void main(String[] args) {
        // 1. Building a bar series
        BarSeries series = new BaseBarSeries();
        series.addBar(10, 12, 9, 11, 100);
        series.addBar(11, 13, 10, 12, 120);
        series.addBar(12, 14, 11, 13, 110);
        series.addBar(13, 15, 12, 14, 130);
        series.addBar(14, 16, 13, 15, 140);
        series.addBar(15, 17, 14, 16, 150);

        // 2. Strategy design
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
        SMAIndicator shortSma = new SMAIndicator(closePrice, 2);
        SMAIndicator longSma = new SMAIndicator(closePrice, 4);
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(shortSma, longSma), new UnderIndicatorRule(shortSma, longSma));

        // 3. Backtesting the strategy
        TimeSeriesManager seriesManager = new TimeSeriesManager(series);
        TradingRecord tradingRecord = seriesManager.run(strategy);

        // 4. Analyzing trade costs
        // Assuming a commission of 0.1% per trade
        double commission = 0.001;
        System.out.println("Average Transaction Cost: " + new AverageTransactionCostCriterion(commission).calculate(series, tradingRecord));
        // Other criteria can also be used to analyze performance considering costs.
    }
}
```

--------------------------------

### Proposed ta4j-examples Modernization

Source: https://github.com/ta4j/ta4j-wiki/blob/master/architecture/proposed/ew-enhancements-part-2/TODO-ta4j-elliottwave-enhancements-part-2.md

Details the planned updates and new examples for the ta4j-examples module, focusing on Elliott Wave analysis demonstrations.

```plaintext
- Update existing `ElliottWaveAnalysis` example to print **confidence breakdown** including time alternation data.
- Add `ElliottWaveAdaptiveSwingAnalysis` example demonstrating:
  - ATR-adaptive zigzag threshold
  - composite confirmation (fractal + zigzag)
- Add `ElliottWavePatternProfileDemo` showing pattern-specific profiles and their effect on ranking.
```

--------------------------------

### ATR Indicator Test Class Extension Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/XLS-Testing.md

Demonstrates how to modify the IndicatorTest extension for indicators that use BarSeries data, such as ATR.

```java
public class ATRIndicatorTest extends IndicatorTest<BarSeries, Decimal>
```

--------------------------------

### Configure ElliottWaveFacade with Custom Parameters

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Illustrates how to apply custom Fibonacci tolerance and swing compressors to the facade factory methods.

```java
// Custom Fibonacci tolerance and swing compressor
Num customTolerance = series.numFactory().numOf(0.25);
ElliottSwingCompressor compressor = new ElliottSwingCompressor(series); // 1% of price, 2 bars minimum

// Fractal with custom configuration
ElliottWaveFacade facade = ElliottWaveFacade.fractal(
    series, 5, ElliottDegree.INTERMEDIATE, 
    Optional.of(customTolerance), 
    Optional.of(compressor)
);

// ZigZag with custom configuration
ElliottWaveFacade facade = ElliottWaveFacade.zigZag(
    series, ElliottDegree.INTERMEDIATE,
    Optional.of(customTolerance),
    Optional.of(compressor)
);

// From custom swing indicator with configuration
ElliottWaveFacade facade = ElliottWaveFacade.from(
    customSwingIndicator, 
    closePriceIndicator,
    Optional.of(customTolerance),
    Optional.of(compressor)
);
```

--------------------------------

### Swing Adaptivity Implementation Checklist

Source: https://github.com/ta4j/ta4j-wiki/blob/master/architecture/proposed/ew-enhancements-part-2/TODO-ta4j-elliottwave-enhancements-part-2.md

Tracks the implementation status of various components related to swing adaptivity in Elliott Wave analysis.

```plaintext
- [x] Add `SwingDetector` interface + adapters around existing `RecentSwingIndicator` style detectors.
- [x] Implement `AdaptiveZigZagSwingDetector` (config: ATR period, min/max threshold, smoothing).
- [x] Implement `CompositeSwingDetector` (policy: AND/OR; reconcile pivot disagreements).
- [x] Implement `MinMagnitudeSwingFilter` (relative-to-largest-swing or ATR-based).
- [x] Add unit tests with synthetic volatility regime shifts.
```

--------------------------------

### Run local Elliott Wave snapshot analysis via CLI

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Quickstart.md

Executes the ElliottWavePresetDemo to generate a macro-cycle report for a specific instrument and duration.

```bash
./mvnw -pl ta4j-examples -am exec:java \
  -Dexec.mainClass=ta4jexamples.analysis.elliottwave.ElliottWavePresetDemo \
  -Dexec.args="live Coinbase BTC-USD PT1D 1825"
```

--------------------------------

### ADX Strategy Example

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Canonical-User-Journey.md

Implements the Average Directional Movement Index (ADX) trading strategy. This strategy is useful for identifying trend strength.

```java
import org.ta4j.core.BarSeries;
import org.ta4j.core.BaseStrategy;
import org.ta4j.core.Strategy;
import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
import org.ta4j.core.indicators.ADXIndicator;
import org.ta4j.core.rules.OverIndicatorRule;
import org.ta4j.core.rules.UnderIndicatorRule;

public class ADXStrategy {

    public static Strategy buildStrategy(BarSeries series) {
        // We need to define the trading session timeframe
        // For example, for a daily series, we can use 14 days
        int timeFrame = 14;

        // Close price indicator
        ClosePriceIndicator closePrice = new ClosePriceIndicator(series);

        // ADX indicator
        ADXIndicator adx = new ADXIndicator(series, timeFrame);

        // Strategy rules
        // Buy rule: ADX crosses above 25 (indicating a strong trend)
        Strategy strategy = new BaseStrategy(new OverIndicatorRule(adx, 25), new UnderIndicatorRule(adx, 25));

        // Set unstable bars for the strategy
        // This is important for indicators that need a certain amount of data to be calculated correctly
        strategy.setUnstableBars(timeFrame);

        return strategy;
    }
}
```

--------------------------------

### Configure Custom Swing Detection

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Elliott-Wave-Indicators.md

Shows how to initialize ElliottWaveFacade using custom price sources or specific swing configurations.

```java
// Use close prices instead of high/low
ClosePriceIndicator close = new ClosePriceIndicator(series);
ElliottSwingIndicator swings = new ElliottSwingIndicator(close, 3, 3, ElliottDegree.INTERMEDIATE);

// Create facade from custom swing indicator
ElliottWaveFacade facade = ElliottWaveFacade.from(swings, close);

// Or with custom configuration
Num fibTolerance = series.numFactory().numOf(0.25);
ElliottSwingCompressor compressor = new ElliottSwingCompressor(series);
ElliottWaveFacade facade = ElliottWaveFacade.from(
    swings, 
    close, 
    Optional.of(fibTolerance), 
    Optional.of(compressor)
);
```

--------------------------------

### Quick One-off Load (Static Method)

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Data-Sources.md

Demonstrates a quick, one-off data load using a static method. This method does not utilize caching and is suitable for simple scripts.

```java
// Quick one-off load - no caching
BarSeries series = YahooFinanceHttpBarSeriesDataSource.loadSeries("AAPL", 365);
```

--------------------------------

### Get Latest Tag

Source: https://github.com/ta4j/ta4j-wiki/blob/master/completed-features/RELEASE_PROCESS_PRD.md

Retrieves the most recently created tag based on the creator date. This is useful for identifying the absolute latest tag in the repository.

```bash
latest_tag=$(git tag --sort=-creatordate | head -1)
```

--------------------------------

### Run a Backtest with BarSeriesManager

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Getting-started.md

Initialize a `BarSeriesManager` with your bar series and run the strategy to obtain trading records. This provides a basic backtesting execution.

```java
BarSeriesManager manager = new BarSeriesManager(series);
TradingRecord record = manager.run(strategy);

System.out.printf("Closed positions: %d%n", record.getPositionCount());
System.out.printf("Current position open? %s%n", record.getCurrentPosition().isOpened());
```

--------------------------------

### Instantiate and Use BarSeriesDataSource Implementations

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Data-Sources.md

Demonstrates how to instantiate different BarSeriesDataSource implementations (Yahoo Finance, CSV, JSON) and load BarSeries data using business domain concepts like ticker, interval, and date range. Also shows loading directly from a filename.

```java
// All data sources share the same interface
BarSeriesDataSource yahoo = new YahooFinanceHttpBarSeriesDataSource(true); // With caching
BarSeriesDataSource csv = new CsvFileBarSeriesDataSource();
BarSeriesDataSource json = new JsonFileBarSeriesDataSource();

// Same interface, different implementations

// retrieve AAPL Daily OHLC data from Yahoo Finance's API
BarSeries aapl = yahoo.loadSeries("AAPL", Duration.ofDays(1), 
    Instant.parse("2023-01-01T00:00:00Z"),
    Instant.parse("2023-12-31T23:59:59Z"));

// retrieve BTC-USD Daily OHLC data from a local CSV file using domain-level criteria (file system abstracted away)
BarSeries btc = csv.loadSeries("BTC-USD", Duration.ofDays(1),
    Instant.parse("2023-01-01T00:00:00Z"),
    Instant.parse("2023-12-31T23:59:59Z"));

// of course you can also retrieve by filename
BarSeries eth = json.loadSeries("Coinbase-ETH-USD-PT1D-20241105_20251020.json");

```

--------------------------------

### Construct a trading strategy

Source: https://github.com/ta4j/ta4j-wiki/blob/master/Trading-strategies.md

Initializes a strategy with entry and exit rules, optionally setting an unstable bar window.

```java
Strategy strategy = new BaseStrategy("SMA + MACDV hybrid", entryRule, exitRule);
strategy.setUnstableBars(30); // optional: indicators already report their own unstable window
```
Tokens:
Raw