Elliott Wave Analysis

Analyze wave patterns with confidence scoring using ElliottWaveFacade and ElliottWaveAnalysisRunner.

Elliott Wave theory divides price movement into two structural patterns: a five-wave impulse sequence (waves 1–5) in the direction of the dominant trend, followed by a three-wave correction (waves A–B–C) against it. ta4j implements this analysis as a layered stack of indicators — you choose how much of the stack to expose.

Two entry points are available:

• ElliottWaveFacade — indicator-style, per-bar access. Use this in strategy rules and chart overlays when you want live signals at each bar index.
• ElliottWaveAnalysisRunner — one-shot analysis pipeline. Use this when you need a complete snapshot: multi-degree scenario ranking, confidence breakdowns, and cross-degree compatibility scores.

ElliottWaveFacade

ElliottWaveFacade wires the full indicator stack from a single configuration and exposes each indicator as a lazily-created getter. All indicators share the same underlying swing detector, so they always analyse the same wave structure.

Creating a facade

Fractal swing detection

// Symmetric window: 5 bars inspected before and after each pivot candidate
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 5, ElliottDegree.INTERMEDIATE);

ZigZag swing detection

// Uses ATR(14) as the reversal threshold — works well for volatile assets
ElliottWaveFacade facade = ElliottWaveFacade.zigZag(series, ElliottDegree.MINOR);

Asymmetric fractal

// Separate lookback (3) and look-forward (5) windows
ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 3, 5, ElliottDegree.INTERMEDIATE);

Custom swing indicator

// Bring your own swing detector
ElliottSwingIndicator customSwing = new ElliottSwingIndicator(series, 4, ElliottDegree.MINOR);
ClosePriceIndicator price = new ClosePriceIndicator(series);
ElliottWaveFacade facade = ElliottWaveFacade.from(customSwing, price);

Quickstart (from the README)

BarSeries series = // ... your series
int index = series.getEndIndex();

ElliottWaveFacade facade = ElliottWaveFacade.fractal(series, 5, ElliottDegree.INTERMEDIATE);

ElliottPhase phase     = facade.phase().getValue(index);
ElliottScenarioSet scenarios = facade.scenarios().getValue(index);
Num invalidation       = facade.invalidationLevel().getValue(index);

Available indicators

Each indicator is created lazily on first access.

Getter	Return type	What it gives you
facade.phase()	ElliottPhaseIndicator	Current wave phase as ElliottPhase
facade.ratio()	ElliottRatioIndicator	Fibonacci ratio between adjacent swings
facade.channel()	ElliottChannelIndicator	Upper, lower, and median trend channel
facade.waveCount()	ElliottWaveCountIndicator	Raw swing count
facade.filteredWaveCount()	ElliottWaveCountIndicator	Swing count after noise compression
facade.confluence()	ElliottConfluenceIndicator	Confluence score across ratio + channel signals
facade.invalidation()	ElliottInvalidationIndicator	Boolean invalidation flag
facade.invalidationLevel()	ElliottInvalidationLevelIndicator	Numeric invalidation price level
facade.scenarios()	ElliottScenarioIndicator	Ranked alternative wave interpretations
facade.projection()	ElliottProjectionIndicator	Fibonacci-based price targets
facade.trendBias()	ElliottTrendBiasIndicator	Directional bias derived from scenarios

Convenience methods on the facade

// Primary (highest-confidence) scenario at a bar index
Optional<ElliottScenario> primary = facade.primaryScenario(index);

// All other ranked alternatives
List<ElliottScenario> alternatives = facade.alternativeScenarios(index);

// Confidence score [0.0–1.0] for a specific phase
Num confidence = facade.confidenceForPhase(index, ElliottPhase.WAVE3);

// Check if high-confidence scenarios agree on the same phase
boolean consensus = facade.hasScenarioConsensus(index);

// Get the consensus phase (or ElliottPhase.NONE if disagreement)
ElliottPhase agreed = facade.scenarioConsensus(index);

// Human-readable summary of the current scenario set
String summary = facade.scenarioSummary(index);

Scenario modes for invalidation levels

ElliottInvalidationLevelIndicator supports three modes through ElliottScenarioIndicator:

• PRIMARY — invalidation price from the top-ranked scenario only.
• CONSERVATIVE — tightest (closest) invalidation across all high-confidence scenarios.
• AGGRESSIVE — widest (farthest) invalidation across all scenarios.

Custom Fibonacci tolerance and swing compression

Num customTolerance = series.numFactory().numOf(0.25); // 25% Fibonacci tolerance
ElliottSwingCompressor compressor = new ElliottSwingCompressor(series); // 1% amplitude, 2-bar minimum

ElliottWaveFacade facade = ElliottWaveFacade.fractal(
        series,
        5,
        ElliottDegree.INTERMEDIATE,
        Optional.of(customTolerance),
        Optional.of(compressor));

ElliottDegree

ElliottDegree labels the expected time scale of your swings. Use it to keep indicator configurations consistent with the bar resolution of your series.

All ElliottDegree values

Value	Typical time horizon	Recommended bar type
GRAND_SUPERCYCLE	Multi-decade to century	Monthly/weekly
SUPER_CYCLE	Decades	Weekly
CYCLE	Years	Weekly/daily
PRIMARY	Months to years	Daily (400–1 000 bars)
INTERMEDIATE	Weeks to months	Daily (180–400 bars)
MINOR	Days to weeks	Daily/hourly
MINUTE	Hours to days	Daily/hourly
MINUETTE	Minutes to hours	Minute/hourly
SUB_MINUETTE	Minutes and below	Minute

ElliottDegree can suggest appropriate degrees for your data at runtime:

// Returns a ranked list of degrees that fit this series
List<ElliottDegree> recommended = ElliottDegree.getRecommendedDegrees(
        series.getFirstBar().getTimePeriod(),
        series.getBarCount());

ElliottPhase

ElliottPhase identifies which leg of the wave structure the market is currently in.

Impulse phases: WAVE1, WAVE2, WAVE3, WAVE4, WAVE5

Corrective phases: CORRECTIVE_A, CORRECTIVE_B, CORRECTIVE_C

Special value: NONE — no qualifying swing structure detected yet.

ElliottPhase phase = facade.phase().getValue(index);

if (phase.isImpulse()) {
    System.out.println("Impulse wave " + phase.impulseIndex()); // 1–5
} else if (phase.isCorrective()) {
    System.out.println("Corrective wave " + (char)('A' + phase.correctiveIndex() - 1));
}

if (phase.completesStructure()) {
    System.out.println("Structure complete — expecting reversal or higher-degree move");
}

ElliottWaveAnalysisRunner

ElliottWaveAnalysisRunner runs a complete one-shot analysis pipeline. It optionally validates scenarios across neighboring degrees and re-ranks them using cross-degree compatibility.

1. Build the runner

   ElliottWaveAnalysisRunner runner = ElliottWaveAnalysisRunner.builder()
           .degree(ElliottDegree.INTERMEDIATE)   // base degree
           .higherDegrees(1)                     // include one degree above
           .lowerDegrees(1)                      // include one degree below
           .minConfidence(0.2)                   // prune weak scenarios
           .maxScenarios(5)                      // keep at most 5 alternatives
           .build();
   
2. Run the analysis

   ElliottWaveAnalysisResult result = runner.analyze(series);
   
3. Read ranked scenarios

   // Base-degree scenarios ranked by composite score
   List<ElliottWaveAnalysisResult.BaseScenarioAssessment> ranked = result.rankedBaseScenarios();
   
   for (ElliottWaveAnalysisResult.BaseScenarioAssessment assessment : ranked) {
       ElliottScenario scenario = assessment.scenario();
       double confidence   = assessment.confidenceScore();    // base confidence [0.0–1.0]
       double crossDegree  = assessment.crossDegreeScore();   // cross-degree compatibility [0.0–1.0]
       double composite    = assessment.compositeScore();     // blended final score
       System.out.printf("Phase=%-15s confidence=%.2f crossDegree=%.2f composite=%.2f%n",
               scenario.currentPhase(), confidence, crossDegree, composite);
   }
   
4. Inspect per-degree analyses

   // All degree snapshots (higher → base → lower)
   for (ElliottWaveAnalysisResult.DegreeAnalysis analysis : result.degreeAnalyses()) {
       ElliottAnalysisResult degreeResult = analysis.analysis();
       System.out.printf("Degree=%-15s bars=%d trendBias=%s%n",
               analysis.degree(), analysis.barCount(), degreeResult.trendBias());
   }
   

Builder options

All builder options

Method	Default	Description
.degree(ElliottDegree)	required	Base degree that drives scenario ranking
.higherDegrees(int)	1	Number of higher degrees to include (0 to disable)
.lowerDegrees(int)	1	Number of lower degrees to include (0 to disable)
.baseConfidenceWeight(double)	0.7	Weight in [0.0, 1.0] for base confidence vs. cross-degree score
.minConfidence(double)	0.15	Minimum confidence threshold for scenario inclusion
.maxScenarios(int)	library default	Maximum number of scenarios to retain
.scenarioSwingWindow(int)	5	Swings passed to scenario generation (0 = all)
.swingDetector(SwingDetector)	adaptive ZigZag (ATR 14)	Override the swing detector
.swingFilter(SwingFilter)	auto-scaled by degree	Override the swing filter
.confidenceModel(ConfidenceModel)	ConfidenceProfiles.defaultModel()	Override the confidence scorer
.patternSet(PatternSet)	PatternSet.all()	Restrict which pattern types are generated
.seriesSelector(SeriesSelector)	trims to max history per degree	Override how series are sliced per degree
.analysisRunner(AnalysisRunner)	built-in pipeline	Override the entire per-degree pipeline

The confidence scorer weights five factors: Fibonacci proximity (35%), time proportions (20%), alternation quality (15%), channel adherence (15%), and structure completeness (15%). Pass a custom ConfidenceModel via .confidenceModel(...) to change these weights.

Example classes

All examples are in the ta4j-examples module under ta4jexamples.analysis.elliottwave.

Class	What it demonstrates
ElliottWaveIndicatorSuiteDemo	Full indicator suite — swings, phases, Fibonacci, channels, confidence, scenarios, charts. Defaults to an ossified dataset; supports YahooFinance or Coinbase via command-line arguments.
ElliottWavePresetDemo	Consolidated launcher for preset ossified assets (btc, eth, sp500) and live mode with any ticker.
ElliottWaveAdaptiveSwingAnalysis	Adaptive/composite swing detection for scenario generation.
ElliottWavePatternProfileDemo	Comparison of default and pattern-aware confidence profiles.
ElliottWaveMultiDegreeAnalysisDemo	Cross-degree validation and scenario recommendation.
ElliottWaveTrendBacktest	Trend-bias directionality over backtest and walk-forward windows.
HighRewardElliottWaveBacktest	High-reward Elliott Wave strategy presets.

Run any example with:

# Linux/macOS
./mvnw -pl ta4j-examples exec:java \
  -Dexec.mainClass=ta4jexamples.analysis.elliottwave.ElliottWaveIndicatorSuiteDemo

# Windows CMD
mvnw.cmd -pl ta4j-examples exec:java "-Dexec.mainClass=ta4jexamples.analysis.elliottwave.ElliottWaveIndicatorSuiteDemo"

ElliottWaveIndicatorSuiteDemo accepts optional command-line arguments to load live data: [dataSource] [ticker] [barDuration] [startEpoch] [endEpoch]. For example, pass YahooFinance AAPL PT1D 1672531200 1704067200 to analyse daily AAPL bars.