Ta4j Wiki

Documentation, examples and further information of the ta4j project

View the Wiki On GitHub

This project is maintained by ta4j Organization

PRD + ARD — TA4J Elliott Wave Engine Enhancements (feature/ew-analysis-improvements)

Branch scope: ta4j/ta4j → feature/ew-analysis-improvements Goal: Turn the improvement recommendations into a testable PRD, plus an architecture + codebase mapping plan aligned to TA4J’s current Elliott Wave package (swing processing, scenario generation, scoring, projections, examples).

PRD

1) Title + 1-line summary

Title: Adaptive, Modular Elliott Wave Analysis & Trading Extensions for TA4J
Summary: Improve Elliott Wave accuracy and usability by adding volatility-adaptive swing detection, time-based alternation scoring, pattern-aware confidence modeling, modular/puggable architecture, optional trade-advisor utilities, and configurable/expanded pattern coverage.

2) Context / problem

TA4J’s Elliott Wave package already provides:

However, the current system can be materially improved in five areas you called out:

  1. Swing detection adaptivity + alternation logic (including time/duration alternation).
  2. Confidence scoring flexibility (dynamic weights, more factors like momentum/volume).
  3. Architecture modularization (clean pluggable pipeline, better live-signal ergonomics).
  4. Live-trading utilities (risk/reward, scaling, advisor objects).
  5. Pattern coverage + pattern-set customization (diagonals, complex corrections, etc.).

3) Goals + non-goals

Goals

Non-goals

4) Users/personas + key use cases

Personas

Key use cases

5) Requirements

MVP — Functional

A) Enhanced swing detection & swing compression
  1. Volatility-adaptive ZigZag threshold
    • Support dynamic threshold driven by ATR/volatility regime so pivots don’t disappear in high-volatility periods.
  2. Composite swing confirmation
    • Allow confirming pivots via multiple detectors (e.g., Fractal(5) AND ZigZag(%)) before accepting a swing.
  3. Noise swing filtering
    • Add minimum-magnitude rules (e.g., ignore swings < X% of the largest swing in window) to prevent “jitter waves.”
  4. Time-aware alternation inputs
    • Ensure swings retain bar-index/time metadata needed for duration comparisons downstream.
B) Alternation scoring: add time/duration dimension
C) Richer confidence modeling (dynamic & multi-factor)
  1. Pattern-aware weight profiles
    • Confidence scoring can select weights by ScenarioType (Impulse vs Triangle etc.).
  2. Granular fib relationships
    • Break “fib proximity” into individually scored relationships (W2 retrace, W3 extension, W4 retrace, W5 targets, A/B/C relations) using existing validator-style continuous scoring.
  3. Extensible factor framework
    • New factors can be added without rewriting the scorer; each factor contributes:
      • score (0..1)
      • weight
      • diagnostics (computed values, thresholds, deltas)
D) Architectural refactor & modularization
E) Pattern coverage and customization

MVP — Non-functional

Later — Functional

6) Proposed solution

Pipeline (conceptual)

  1. Detect candidate swing points (one or more detectors).
  2. Optionally “confirm” swings via composite rules.
  3. Compress/normalize swings to target degree.
  4. Generate scenarios for enabled patterns.
  5. Score each scenario with pattern-aware confidence profiles.
  6. Compute invalidation + targets + (later) R/R advisory.

Java API sketch (ta4j-style)

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();

7) Constraints, edge cases, dependencies

8) Success metrics + telemetry

9) Rollout/release plan + backward compatibility

  1. Introduce new APIs as additive (ElliottWaveAnalyzer, factor framework, profiles).
  2. Keep existing ElliottWaveFacade usage working; optionally implement facade via analyzer internally.
  3. Ship new examples (and/or update existing examples) to show:
    • adaptive swings
    • time alternation scoring output
    • per-pattern confidence profiles

10) Risks + mitigations

11) Open questions

12) Acceptance criteria + test plan

ARD — Architecture + Codebase Mapping (feature/ew-analysis-improvements)

A) Current Elliott Wave surface (what exists today)

The Elliott Wave feature set includes (at minimum) the following conceptual components and classes (per TA4J release notes and documentation):

Examples exist under ta4j-examples such as ElliottWaveAnalysis, BTCUSDElliottWaveAnalysis, etc.

Mapping note: the exact package paths may differ slightly in-branch, but TA4J’s Elliott Wave implementation is clearly structured around these components.

B) Proposed package layout (additive, minimal disruption)

1) ta4j-core: Elliott Wave analysis package

Target root (existing):

Add subpackages (if they don’t already exist) to formalize the pipeline:

2) ta4j-examples: example modernization + new examples

Target root:

Add/Update:

C) Design decisions (to keep it TA4J-native)

  1. Preserve “multiple scenarios” as core output (ElliottScenarioSet stays).
  2. Favor immutable records/POJOs for outputs (ElliottConfidence, ElliottScenario, ElliottScenarioSet are already record-like).
  3. Use continuous scoring (0..1) for factors (consistent with ElliottFibonacciValidator proximity scoring approach).
  4. Keep defaults simple: current weights remain the default profile unless overridden, to avoid breaking user expectations.

D) Concrete implementation checklist (mapped to code areas)

D1) Swing adaptivity

D2) Time alternation scoring

D3) Confidence model refactor

D4) Analyzer orchestration

D5) Pattern set configuration

D6) Examples

E) Minimal API additions (proposed)

public interface SwingDetector {
    RecentSwings detect(BarSeries series, SwingDetectorConfig config);
}

public interface ConfidenceFactor {
    String name();
    FactorResult score(ElliottContext ctx, ElliottScenario scenario);
}

public final class ElliottWaveAnalyzer {
    // builder with swingDetector, compression, generator, confidence model
    public ElliottAnalysisResult analyze(BarSeries series);
}

F) Compatibility notes

References