FAQ

We have an entire page including two videos on that!

EWAVES Live currently covers a selection of Commodities, Crypto, Forex, US Stock & Bond Indices, US ETFs and US Stocks. For a full list of covered assets or if you wish for additional coverage, please email us at info@ewaves.com.

We are currently partnered with Trade Navigator.

EWAVES Live starts updating its charts (using the latest end-of-day daily bar data) every night at 8 PM EST. It takes some time for processing, so updated charts will not be available until about 8:15 PM EST. All charts and associated data files are updated simultaneously in an atomic manner.

If you are using the site at the time the update completes, an alert will appear instructing you to refresh your browser window, in order to view new charts.

If you wish to know how up-to-date a chart is, each chart displays the date of its last data point in (1) its copyright date and (2) the last date on its horizontal date axis.

The labels mostly use the labeling convention described in Frost & Prechter’s book Elliott Wave Principle. Impulses and diagonals use 1-2-3-4-5, zigzags and flats use A-B-C, and complex corrections use W-X-Y.

The only slightly unusual labeling are triangles, which are lowercase a-b-c-d-e. This distinction is important for two reasons:

(1) The internals of triangle waves “a” and “b” resemble the internals of flat waves “A” and “B”, so we require different labels for disambiguation. No other pattern has this issue.

(2) Sometimes, in the Wave Finder (an Elliott wave search engine; see “Wave Finder” section below for details), you may want to specify “the last wave of a correction,” which would be “C” for a zigzag or flat, but “e” for a triangle.

EWAVES’ wave counts will not necessarily align with any particular analyst’s market opinion. Users may review its analysis in isolation or seek to incorporate it with other sources or tools.

The reflection of social mood in freely traded markets is imperfect. Therefore, it is generally not possible to label Elliott waves without incorporating some subwaves that do not subdivide cleanly, or that appear to subdivide in ways which do not match their context.

Additionally, all market data formats contain artifacts, making the internal wave structure impossible to discern over short-term intervals. For example, a beautiful five-wave structure on an hourly chart may appear as a three-wave structure when looking at the corresponding daily bars.

To allow EWAVES to count real world data, it is allowed to “squint” over data segments in much the same way that human practitioners do. The resulting waves simply have no internal structure, i.e., they are of an “unknown” type. Their meaning comes from the larger context in which they occur.

EWAVES Live identifies the data provider to the right of each chart’s title. Generally, the data should match that served by the provider precisely. It may or may not match the data served by a different provider.

There are a couple caveats:

(1) For Stocks/ETFs: EWAVES requires split adjustments on equities/ETFs but disables dividend adjustments. It does so for two reasons. First, total returns do not reflect Elliott waves as well as the direct price action. Second, many data providers model dividends using arithmetic adjustments (rather than multiplicative adjustments), which causes back adjusted prices to go negative. Negative prices cannot be converted to log scale for Elliott wave analysis.

(2) For Futures: Leaving futures data as-is does not work, because there are large gaps between successive contracts as a result of differences in the premium/discount of each contract. Attempting to simulate a continuous contract by using arithmetic offsets (the usual method that data providers use) leads to negative back adjusted prices, which cannot be converted to log scale for wave analysis. To better simulate real prices, EWAVES employs a custom back-adjustment scheme, which solves the aforementioned problems. But it also means that the data will not necessarily match the provider’s own back-adjusted prices. The data for the most recent contact will always match.

EWAVES does not consider unlimited analysis detail. It instead focuses the analysis detail on where it’s most needed. The rule of thumb for this is simple: waves that are closer to the present are analyzed with more detail than waves that are in the distant past. This gives plenty of detail where it’s needed, but sometimes the tiny details of distantly-past waves will exhibit artifacts, because EWAVES cannot “see” every last movement within their internal structure.

This design decision was done or two reasons.

First, it shifts more processing time to where it’s most needed. The analysis process is extremely CPU intensive and cannot consider all available detail. (That said, we are presently working on a new, more advanced algorithm that will likely allow for significantly increased past details. It is not yet ready for production use.)

Second, it is sometimes important to not consider every detail of past waves. Sometimes the market moves in ways where the internal structure of the past is no longer valid, and so placing less emphasis on those little details allows the program to be flexible in a way required for wave analysis. For example, a wave that does not exhibit a clear zigzag structure may be interpreted best as an impulse in real time, but in retrospect may be treated as a zigzag if that is the only valid way to integrate it into a reasonable larger wave count.

EWAVES is not an automated black-box trading system. It’s a powerful research tool that helps traders to quickly identify and rank Elliott wave patterns. EWAVES can find, for example, unfolding third waves across thousands of markets.

Many of the most popular Elliott wave trading setups are included as Wave Finder templates, but you can also design your own setups. Trading results will depend heavily on which opportunities a trader choose to act on and how they choose to trade.

Elliotticity is the degree to which a data segment adheres to the Elliott Wave Principle. It varies from 0% to 100%. Each individual Elliott wave spans a data segment with an elliotticity rating corresponding to the quality of its internal structure.

Additionally, to ensure each wave’s elliotticity has a strong meaning, each wave’s elliotticity also includes a modest amount of extra context, i.e. it mixes in some of the elliotticity of other surrounding waves. This makes perfect sense when you consider a wave that has just begun: obviously, the elliotticity of the preceding wave is what you should focus on, because the new wave has virtually no discernible structure yet.

A perhaps unexpected aspect of how EWAVES implements elliotticity is that it is scale invariant. The recent daily picture is given as much consideration as the recent weekly picture, which is given as much consideration as the recent monthly picture, and so on. In this way, elliotticity is as equally sensitive to short-term market activity as it is to long-term market activity. In other words, a wave with high elliotticity counts well at all degrees of scale, from the past to the present.

In past newsletters, we have referred to the elliotticity of the largest wave in a market as the market’s total elliotticity. As a result of time frame invariance, total elliotticity is perhaps the most generally useful single numerical value for ranking markets against one another in terms of Elliott wave conformance. If a market has high total elliotticity, then you should be able zoom all the way in, or all the way out, and the market should adhere well to the Elliott wave model at all timescales.

Total elliotticity is the default ranking method used (if sorting markets by elliotticity) when the Wave Finder is inactive. When using the Wave Finder, the elliotticity value will correspond to each wave that you find. That gives you the option to focus on shorter-term elliotticity rather than total, which can be more useful when the highest-degree waves are unimportant (which is generally the case, since for example you usually do not care about the multi-century picture).

Sacha Sardo-Infirri, Ph.D, and Elliott Prechter have finished research for their upcoming paper, “Using The Elliott Wave Model To Distinguish Real From Randomly Permuted Financial Returns.” In it, they show that EWAVES can tell the difference between real market prices and randomized versions across major markets and indexes like DJIA, Nasdaq, Gold, and even Bitcoin.

The results establish elliottcity as a new statistically significant stylized fact for financial data series. This is a breakthrough in financial market theory. This evidence that financial data follow fractal patterns contradicts the long-held random walk hypothesis.

The following histogram demonstrates the differences in elliotticity between real 1-year chunks and randomized versions thereof (via permutations of fixed-period returns) across all available daily data for the Dow Jones Industrials, Dow Jones Transports, S&P 500, Nasdaq 100, Russell 2000, Spot Gold, the Dollar Index and Bitcoin. All results are out-of-sample by using custom builds of EWAVES that excluded the market-under-test from its database of iconic counts. Of course, much more detailed and granular results will be present in the paper.

Elliotticity values are not percentiles (i.e. a relative rank of wave conformance), but are absolute percentages from 0% to 100% determining how conformant individual waves are to the Elliott Wave Principle. The higher the value, the better.

As of the most recent version of the EWAVES engine, you’ll find that waves with elliotticities at or above 50% are high quality, with 55% and higher absolutely the best-in-class. Below around 38% is where waves start exhibiting potentially problematic issues, including but not limited to (1) unlabeled/unknown substructure (2) contextual waves are poor quality (3) extrapolation of existing structure is highly probable to break Elliott wave rules.

In theory, Elliotticity could be as high as 100%, but that is only practically possible when using data that is artificially constructed to conform to idealized Elliott waves. Real world data rarely gets much beyond 50% conformance.

EWAVES Live has a built-in Wave Finder, which is the world’s first Elliott wave search engine. It is a query system for quickly finding currently-unfolding Elliott waves based on precise criteria.

There are several built-in templates that you can use directly to find Elliott wave setups, or you can modify these templates to get started on your own custom setups.

Templates make the Wave Finder much easier to use, by having ready-made Elliott wave setups at your fingertips. The templates appear in a drop-down menu just beneath the Wave Finder header on the left-hand-side. You can either use the template directly, or modify it to suite your needs.

Here is an example of the “Zigzag flat (early)” template with a minor modification: instead of requiring wave 4 of C to be broken on the upside, breaking the trend channel formed by wave C is sufficient. This gives us an even earlier entry than the template provides.

Yes! Go here to watch the EWAVES Live tutorial video. The video describes how to use EWAVES Live, as well as the Wave Finder query system. The video does not mention templates however, as that feature was introduced later on.

There are multiple types of context waves. The context wave called simply “wave” is the actual wave you’re searching for. It is the wave that will be highlighted by the Wave Finder. Many search queries only involve looking for a “wave” with particular attributes (see section “What are the Wave Attributes?” below for details). For example, to find an impulse wave, you would search for a wave with the attribute “type” set to “impulse.”

The other context waves provide the environment (aka “context”) for “wave”. You may, for example, specify attributes for the “prior” context wave. This is the wave structure that precedes the wave you’re searching for. For example, to find waves that follow triangles, you would add the context wave “prior”, and then require that “prior” have the attribute “type” set to “triangle.”

Another context wave is “parent,” which is the larger wave of which “wave” is a component. For example, if you want “wave” to occur in the context of a larger 3rd wave, you would add the context wave “parent” and then require its attribute “label” to be “3.”

The “child” context wave is the last component wave of “wave.” For example, if you were looking for an impulse wave where its 5th wave was in progress, you would add context wave “child” and set its “label” attribute to “5.”

If you wish to specify attributes for a wave larger than “parent”, the grandparent is called “parent(+1)”, the great-grandparent is “parent(+2)”, and so on. Similarly, the grandchild is called is “child(-1)”, the great-grandchild is “child(-2)”, and so on.

Example Query #1 (click image(s) to view in new fullscreen tab)

This example query looks for a newly started impulsive 3rd, 5th or C wave of an impulse or zigzag.

It does so by finding unfolding impulse waves, with label 3, 5 or C, that have retraces 50% or less of their prior waves (i.e. wave 3 has not yet surpassed 50% of wave 2 yet). The parent wave is either an impulse or a zigzag. The prior wave, which must be a corrective 2, 4 or B, must have a duration between 28 and 400 days. Both the wave and the parent wave must have an elliotticity of 50% or greater.

Note that restricting the duration of wave 2 is there because you have to restrict the duration of at least one wave or else you get waves which are far too small or large.

Below is another example scenario found in Bitcoin using the same query:

Example Query #2 (click image(s) to view in new fullscreen tab)

This example query looks for a 5th wave in progress that is showing short-term strength. Therefore, the larger impulse is nearly done.

It does so by finding unfolding impulse waves with a duration between 50 and 400 days, and a minimum elliotticity of 40%. The unfolding child wave is a 5th wave that is less than 50% complete. The unfolding grandchild wave is a 3rd wave which retraced at least 100% of its preceding wave 2.

You can optionally add a linearity requirement to the wave (say, 50% to 100%) to search for particularly strong impulse waves.

EWAVES Live itself has two main data files, which are used to drive the Wave Finder. The easiest way to download these files is by logging into EWAVES Live and downloading them from there.

• markets.json defines the markets for EWAVES Live, with their attendant metadata. It has no dependencies on any other files.

• waves.bin is a supplementary file (which depends on markets.json for market definitions) that is required for the Wave Finder. It defines attributes for every currently unfolding wave in every market.

Please note that the formats for these files are subject to change any time EWAVES Live is upgraded. Therefore, if you wish to take a long-term, hard dependency on EWAVES’ data output, you should probably contact us.

markets.json is a JSON text file. It is so simple and self-documenting that the best way to understand it is to download the current file and simply take a look.

waves.bin is a binary file, composed of a contiguous linear array of waves, representing the set of unfolding waves across all markets. Each wave is a simple POD (plain old data) structure.

The waves are ordered thusly:

• Each wave has a market ID, which links it to a market in markets.json. The waves in waves.bin are written primarily in the order of their market IDs.

• Each wave also has a degree, with the largest degree wave being degree 0, the next-largest being 1, and so on. The waves are written secondarily in the order of their degrees.

• Finally, every single unfolding wave has a matching prior wave (for example, an unfolding wave 5 has a prior wave 4). So, waves are written in pairs, with the prior wave first, and then the actual unfolding wave after.

For example, the set of waves looks something like this:

[market 0, degree 0, prior wave]
[market 0, degree 0, wave]
[market 0, degree 1, prior wave]
[market 0, degree 1, wave]
…
[market 1, degree 0, prior wave]
[market 1, degree 0, wave]
…

The wave structure itself is best represented by the following Rust code snippet:

// Represents the pattern formed by a wave's internal structure
enum WaveType {
    Impulse,
    Diagonal,
    Zigzag,
    Flat,
    Triangle,
    DoubleZig,
    Unknown
}

// Represents the position of a wave in a larger pattern
enum WaveLabel {
    _1, _2, _3, _4, _5, // position in impulse/diagonal
     A,  B,  C,         // position in zigzag/flat
     W,  X,  Y,         // position in double-zig
     a,  b,  c,  d,  e  // position in triangle
}

// wave structure (18 bytes)
#[repr( C, packed )] #[derive( Copy, Clone, Debug )] pub struct Wave {
    market: u16, // which market this wave is a member of
    degree: u8, // largest wave is degree 0, next-largest is 1, etc.
    zoom: u8, // the smallest zoom level that can view this entire wave
    type_label: u8, // type (4-bits) | label (4-bits)
    elliotticity: u8, // % elliotticity, from 0 (0%) to 200 (100%)
    linearity: u8, // % linearity, from 0 (0%) to 200 (100%)
    complete: u8, // % complete, from 0 (0%) to 200 (100%)
    duration: f16, // years (365.2425 days) from start to now
    duration_remaining: f16, // expected years from now to end
    magnitude: f16, // log return from start to now
    magnitude_remaining: f16, // expected log return from now to end
    retrace: f16, // % retracement thus far relative to prior wave
}