Bridging 19th‑century mathematics and 21st‑century trading methods

A client sent me what looked like a simple indicator written in TradingView’s Pine Script—though I didn’t realize it was Pine at first—and asked if I could port it to EasyLanguage (or PowerLanguage for MultiCharts). If you Google “Gaussian Channel Donovan Wall TradingView,” you’ll find the original code. Pine Script isn’t exactly newcomer-friendly; it’s fine once you get the feel for it, but I’m spoiled by EasyLanguage, which —at least to my eye—reads almost like plain English. (Others may beg to differ!) Below is a brief Pine snippet; to this humble EL devotee, it’s more hieroglyphics than prose.

    _m2 := _i == 9 ? 36  : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
    _m3 := _i == 9 ? 84  : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
    _m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5  : _i == 4 ? 1 : 0
    _m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6  : _i == 5 ? 1  : 0 
    _m6 := _i == 9 ? 84  : _i == 8 ? 28 : _i == 7 ? 7  : _i == 6 ? 1  : 0 
    _m7 := _i == 9 ? 36  : _i == 8 ? 8  : _i == 7 ? 1  : 0 
    _m8 := _i == 9 ? 9   : _i == 8 ? 1  : 0 
    _m9 := _i == 9 ? 1   : 0

I could see right away that the code was doing some kind of coefficient “lookup,” so I ran it through ChatGPT to get a quick explanation. The model suggested it was building weights from Pascal’s Triangle. A bit later the client sent me the original TradingView post, which confirmed the script was using John Ehlers’s Gaussian filter to build a channel—similar in spirit to Keltner or Bollinger bands.

Once Ehlers’s name popped up, the next stop was his resource-rich site (mesasoftware.com/TechnicalArticles) for the theory behind the filter. I also searched for a ready-made EasyLanguage version but came up empty. With ChatGPT’s help I decided to roll my own; after all, knocking out support code like this is exactly what these AI tools are for.

What do Carl Friedrich Gauss, Blaise Pascal, and the markets have in common.

You’ve probably bumped into the bell curve in school—maybe in a stats class, maybe when teachers “graded on a curve.” Mathematicians call it by a few interchangeable names:

• Normal distribution (stats class)
• Gaussian curve (named after Carl Friedrich Gauss)
• Binomial curve (because it pops out of Pascal’s Triangle)

No matter the label, it’s the same smooth hump that says, “most values cluster in the middle, very few at the extremes.” Gauss formalized the formula, Pascal’s Triangle supplies the ready‑made integer weights, and traders borrow both ideas to build filters that tame noisy price charts.

Big picture: Gauss gives us the shape of the curve, Pascal gives us the exact numbers to approximate it, and that combo lets us create a market indicator that reacts quickly and stays smooth.

How does this help build an indicator?

The word channel is in the name of the indicator, so it was highly likely we are dealing with a smoothed price with an upper and lower band a certain distance from the smoothed price.  If you feed this into Chat GPT and ask for it in EasyLanguage, it will create an indicator using a bunch of arrays.  See Chat GPT isn’t 100% knowledgeable of EasyLanguage like it is with python.  It didn’t understand the concept of EasyLanguage’s serialized variables.  You know where you can refer to a prior value of a variable – myValue[1] or myValue[2].  Chat tries to replicate this with the usage of arrays which gets you into a bunch of trouble right off the bat.  Let’s discuss this a little later.

The Mechanics of smoothing price with Pascal’s Triangle, or Gaussian Kernal or Binomial Coefficients.

(a + b)^2 = a^2 + 2ab + b^2 → coefficients 1  2  1

(a + b)^3 = a^3 + 3a^2b + 3ab^2 + b^3 → coefficients 1  3  3  1

(a + b)^4 = a^4 + 4a^3b + 6a^2b^2 + 4ab^3 + b^4 → coefficients 1  4  6  4  1

(a + b)^5  → coefficients 1  5 10 10  5  1

(a + b)^6 → coefficients 1  6 15 20 15  6  1

(a + b)^7 → coefficients 1  7 21 35 35 21  7  1

(a + b)^8 → coefficients 1  8 28 56 70 56 28  8  1

(a + b)^9 → coefficients 1  9 36 84 126 126 84 36  9  1

Stack those rows, keep going, and you build Pascal’s Triangle—each number is the sum of the two numbers just above it.

Look at the 7th row of Pascal’s Triangle:

1  6  15  20  15  6  1

Normalize those numbers (divide by their sum), and you obtain a discrete approximation of a Gaussian kernel.  Big Deal, right?  You don’t need to know the math behind this, just know that each row in Pascal’s triangle is symmetric.  Each row starts are one and ends at one.  You can use these coefficients to weight each value across a period of time.  Do you mean all this math stuff is akin to a weighted moving average.

Which comes first the indicator or the function that feeds the indicator?

If you are working with code and especially with ChatGPT or any other LLM you need a medium where you can quickly program and observe results.  The indicator analysis module will give you instant results. and this is where you should start.  However, if you look at the TradingView code of the Gaussian Channel you will notice that the smoothing function is called twice, once for the close and once for the true range on each bar.  In other words, you are using the same code twice and incorporating this without functions would be redundant.  In my first attempt, I created the smoothing function and named it Binomial, and the channels were a magnitude of 10 below the current price.  So, all the price bars were scrunched at the very top of the chart.  At first if you don’t succeed, try and try and try and try again.

At first ChatGPT kept insisting on arrays because it didn’t realize EasyLanguage can reference earlier bars just by tagging a variable with [n]. EasyLanguage conveniently hides that bookkeeping, but you have to tell the model so it stops reinventing circular buffers. Once I explained that a local variable—say filt—already remembers its prior values (filt[1], filt[2], etc.), the conversation moved forward.

The next hurdle was clarifying that Donovan’s script feeds raw data (Close and TrueRange) into every stage, not the output of the previous stage. ChatGPT was trying to build a true cascade—each pole using the prior pole’s result—whereas Donovan calculates each pole completely independently. After I pointed that out, the model rewrote the logic correctly and even walked me through the difference:

1. Cascaded filter → Pole 2 uses Pole 1’s output, Pole 3 uses Pole 2’s, and so on.

2. Independent poles → Every pole starts over with the raw Close and Range.

That explanation finally squared the circle and let me produce an EasyLanguage version that matches the original TradingView indicator.

“Cascade” = one stage feeding the next

Think of a cascade as a relay race:

1. Stage 1 (“Pole 1”) takes the raw price, smooths it a little, and hands the baton to …

2. Stage 2 (“Pole 2”), which smooths the output of stage 1 a bit more, then passes to …

3. Stage 3, and so on.

After 4-, 6-, or 9-hand-offs the combined shape of all those little smooths matches the full Gaussian bell.

The indicator lets you pick anywhere from two to nine poles to do the heavy lifting on the data-smoothing. And no, we’re not talking about the North and South Poles—or the kind you cast a fishing line from.

So, what is a pole?

In filter speak, a pole is one little “memory stage” inside the math that reaches back to yesterday’s value (or last bar’s value) before deciding today’s output. Stack more poles and you stack more of those memory stages:

• 1 pole → basically a quick-and-dirty exponential average.

• 4 poles → four mini-averages chained together; much smoother, a hair more lag.

• 9 poles → nine stages deep; super-silky curve, but you’ll feel the delay.

Think of each pole as a coffee filter. One filter catches the big grounds, two filters catch the sludge, and by the time you’ve got nine stacked up, you’re practically drinking distilled water. Same beans in, different smoothness out.

You can dial in two extra tweaks:

• Lag compensation – Tell the code to look one step ahead by swapping in a one-bar forecast of price for the raw price. That little nudge pulls the channel forward so it doesn’t trail the market.
• Extra smoothing – Want the line even silkier? Flip the switch and the function just averages the most-recent two filter values. It’s a tiny moving average—jitter drops a notch, lag creeps up by only half a bar.

For illustrative purposes this is how Pole 6 is calculated.  I also show a mapping scheme to store Pascal’s triangle into arrays.  I put all this code inside a function with the name BinomialFilterN.

{─────────────────────────────────────────────────────────────────────
  2.  Hard-code every Pascal row (n = 1 … 9)
─────────────────────────────────────────────────────────────────────}
once 
begin
    { n = 1 : 1   1 }
    m0Map[1] = 1;    m1Map[1] = 1;

    { n = 2 : 1   2   1 }
    m0Map[2] = 1;    m1Map[2] = 2;    m2Map[2] = 1;

    { n = 3 : 1   3   3   1 }
    m0Map[3] = 1;    m1Map[3] = 3;    m2Map[3] = 3;    m3Map[3] = 1;

    { n = 4 : 1   4   6   4   1 }
    m0Map[4] = 1;    m1Map[4] = 4;    m2Map[4] = 6;    m3Map[4] = 4;
    m4Map[4] = 1;

    { n = 5 : 1   5  10  10   5   1 }
    m0Map[5] = 1;    m1Map[5] = 5;    m2Map[5] = 10;   m3Map[5] = 10;
    m4Map[5] = 5;    m5Map[5] = 1;

    { n = 6 : 1   6  15  20  15   6   1 }
    m0Map[6] = 1;    m1Map[6] = 6;    m2Map[6] = 15;   m3Map[6] = 20;
    m4Map[6] = 15;   m5Map[6] = 6;    m6Map[6] = 1;

    { n = 7 : 1   7  21  35  35  21   7   1 }
    m0Map[7] = 1;    m1Map[7] = 7;    m2Map[7] = 21;   m3Map[7] = 35;
    m4Map[7] = 35;   m5Map[7] = 21;   m6Map[7] = 7;    m7Map[7] = 1;

    { n = 8 : 1   8  28  56  70  56  28   8   1 }
    m0Map[8] = 1;    m1Map[8] = 8;    m2Map[8] = 28;   m3Map[8] = 56;
    m4Map[8] = 70;   m5Map[8] = 56;   m6Map[8] = 28;   m7Map[8] = 8;
    m8Map[8] = 1;

    { n = 9 : 1   9  36  84 126 126  84  36   9   1 }
    m0Map[9] = 1;    m1Map[9] = 9;    m2Map[9] = 36;   m3Map[9] = 84;
    m4Map[9] = 126;  m5Map[9] = 126;  m6Map[9] = 84;   m7Map[9] = 36;
    m8Map[9] = 9;    m9Map[9] = 1;
end;

{─────────────────────────────────────────────────────────────────────
  3.  Working variables
─────────────────────────────────────────────────────────────────────}
variables:
    beta_(0),                      { = 1 – alpha }
    f1(0), f2(0), f3(0), f4(0), f5(0),
    f6(0), f7(0), f8(0), f9(0),
    f(0);

beta_ = 1 - alpha;

{─────────────────────────────────────────────────────────────────────
  4.  Initialise memory until we have enough bars
─────────────────────────────────────────────────────────────────────}
if currentBar <= poleCount then
begin
    f1 = 0; f2 = 0; f3 = 0; f4 = 0; f5 = 0;
    f6 = 0; f7 = 0; f8 = 0; f9 = 0;
end
else
begin
    {================== 1-pole ==================}
    if poleCount = 1 then
    begin
        f1 = m0Map[1]*power(alpha,1)*source
           + m1Map[1]*power(beta_,1)*f1[1];
        f  = f1;
    end;

	{================== 2-pole ==================}
	{================== 3-pole ==================}
	{================== 4-pole ==================}
	{================== 5-pole ==================}
    {================== 6-pole ==================}

    if poleCount = 6 then
    begin
        f6 = m0Map[6]*power(alpha,6)*source
           + m1Map[6]*power(beta_,1)*f6[1]
           - m2Map[6]*power(beta_,2)*f6[2]
           + m3Map[6]*power(beta_,3)*f6[3]
           - m4Map[6]*power(beta_,4)*f6[4]
           + m5Map[6]*power(beta_,5)*f6[5]
           - m6Map[6]*power(beta_,6)*f6[6];
        f  = f6;
    end;

There is redundant code here, but I included it to make it readable for most of my EasyLanguage/PowerLanguage programmers.   The math is very simple when you break it down.  If we choose Pole #6 all we do is:

beta_ = (1 – Cosine(360 / per)) / (Power(1.414, 2 / numPoles) – 1);
alpha = -beta_ + SquareRoot(beta_ * beta_ + 2 * beta);

1. 1 x alpha^6 x close
2. plus 6 x beta^1 x prior f6[1]
3. minus 15 x beta^2 x f6[2]
4. plus 20 x beta^3 x f6[3]
5. minus 15 x beta^4 x f6[4]
6. plus 6 x beta^5 x f6[5]
7. minus 1 x beta^6 x f6[6]

EasyLanguage’s trig calls expect degrees, while most other languages want radians. That’s why the code feeds Cosine(360 / per)—the 360 converts the cycle length into degrees before taking the cosine.

I also lift the constant √2 (1.414…) by squaring it with Power(1.414, 2)and use the same Power routine for roots—for example, the cube root of x is simply Power(x, 1 / 3).

I placed BinomialFilterN inside a second routine called GaussianChannelFunc—a classic wrapper.

Why bother with the extra layer?

Think of it as a coffee machine:

• BinomialFilterN is the brewing unit—hot water + grounds in, espresso out, and it never changes.
• GaussianChannelFunc is the barista: grinds the beans, measures the water, adds milk and foam, then hands you the finished latte. If you want vanilla syrup tomorrow, you ask the barista; you don’t redesign the boiler.

By splitting the work this way, each piece stays focused, easier to test, and simple to extend later.

The wrapper has to hand back three numbers—upper band, centre line, and lower band—yet an EasyLanguage function can formally return only one. The standard workaround is to pass the additional outputs by reference:

// upper are caught by the receiving function as type numericRef
// can get unweilding quickly
value1 = GaussianChannelFunc(src, periods, numOfPoles,compLag, smooth, upper, mid, lower);

That works, but the call quickly turns into a mile-long argument list.
Instead, I bundle those three outputs into a tiny array and pass the array’s address once:

array:GaussianChanArray[3](0); // remember we can use [0]

value1 = GaussianChannelFunc(src, periods, numOfPoles, compLag, smooth,GaussianChanArray);

upperChannel = GaussianChanArray[0];
centreLine   = GaussianChanArray[1];
lowerChannel = GaussianChanArray[2];

This wasn’t that impressive, but what if your function needed to return five values?

Now onto the indicator and the strategy

From the outside this looks like a quick coding job—but getting here was a series of detours. I let ChatGPT drive and only nudged when it went off-track. Here are the dead-ends we hit before the indicator finally behaved:

• Pine-script blind spot
  • ChatGPT didn’t recognise TradingView syntax, so its first translation attempts were gibberish.
• “Mystery math” instead of binomial weights
  • After I mentioned Ehlers and Gaussian smoothing, the model invented a dynamic weighting scheme rather than using the fixed Pascal-triangle numbers the original script relies on.
• Arrays everywhere
  • It kept insisting on circular buffers because it didn’t realise EasyLanguage variables already remember their own history via [1], [2], etc.
• Wrong memory reference
  • Even after the array issue was fixed, the code updated each pole with raw price / range instead of the pole’s own prior output.
• Unwanted filter cascade
  • ChatGPT then tried a true “cascade” (pole 2 fed by pole 1, pole 3 by pole 2). Donovan’s version calculates every pole independently—so we had to unwind that and start over.
• Sign-flip confusion
  • It forgot the plus/minus pattern that keeps the Gaussian zero-lagged, producing a line that trailed price by several bars.

Each course-correction tightened the spec until the model finally spit out the straight, hard-coded-coefficients version you see now.

After all that was it worth the time and analysis?

• A stop version where you buy at and sell short at the upper and lower levels worked best.  Liquidating at the midlevel on a stop was also incorporated.
• Using a large profit objective and a relatively small stop loss seemed to work best.
• Intermediate period length and utilizing 8 poles produced the best results.

ELD for TradeStation and Multicharts

GAUSSIANSTUDY

Text files of functions, indicator and strategies

GaussianChannelFunc Function

Head to Head with Bollinger Bands

Test results across 22 commodities for the past 25 years.

Gaussian Channel:  Optimizing the period and ATR multiplier with 8 poles:

Simple Bollinger Band: optimizing moving average length and number of standard deviations

Conclusion (fight-card style)

Decision on the first bout:
The Rolling heavy-hitter—Bollinger Bands—lands the cleaner power shots and takes the scorecards in our 22-commodity test.

But don’t call it a knockout just yet.
The Recursive counter-puncher—the Gaussian Channel—fights with an extra weapon: pole count. Adjusting those poles changes how tightly the centre line hugs price, and we’ve only sparred with one setting.

Next round:
Tune the poles, test different time-frames, and pit the fighters on equities and FX. The smarter, jabbing Gaussian might steal the rematch once its footwork is dialed in.