Fisher Multi-Pack [DW]

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © DonovanWall

//██████╗ ██╗    ██╗
//██╔══██╗██║    ██║
//██║  ██║██║ █╗ ██║
//██║  ██║██║███╗██║
//██████╔╝╚███╔███╔╝
//╚═════╝  ╚══╝╚══╝
// ------------------------------------------------------------------------------------------------
// Original author:  DonovanWall
// Original title:   Fisher Multi-Pack [DW]
// Licence:          MPL-2.0 (the header above is the original notice, kept verbatim)
// Pine version:     4
// Fetched:          2026-10-12
// Ported to FloScript by FloSignals; modifications under MPL-2.0.
// Converter:        @flosignals/floscript 0.1.0, strict mode, score 100/100
// ------------------------------------------------------------------------------------------------
//@floscript=1
//@version=5
// Converted by the FloScript converter from a Pine-compatible v4 source.

indicator(title="Fisher Multi-Pack [DW]", shorttitle="FMP [DW]")
//by Donovan Wall

//This is an experimental study designed to visualize price activity using John Ehlers Fisher Transform and Inverse Fisher Transform methods.

//The Ehlers Fisher Transform is a variation of R. A. Fisher's Z transformation.

//In this study, there are five oscillator types to choose from:
// -Fisher Transform Indicator - A conversion of price's probability distribution to a Gaussian normal distribution with a smoother output
// -Inverse Fisher Relative Strength Index - Converts the RSI's distribution to a bounded distribution between 1 and -1 with a smoother output
// -Inverse Fisher Stochastic Oscillator - Converts the Stochastic's distribution to a bounded distribution between 1 and -1 with a smoother output
// -Inverse Fisher Commodity Channel Index - Converts the CCI's distribution to a bounded distribution between 1 and -1 with a smoother output
// -Inverse Fisher Blast Off Momentum - Converts the BOM's distribution to a bounded distribution between 1 and -1 with a smoother output

//The study uses a modified set of Bollinger Bands applied to the chosen oscillator to determine trend and impulse activity, which are highlighted by the color scheme.

//Custom bar colors are included.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Updates:

//Cleaned up the script. Removed clutter.

//Removed Inverse Fisher BOM from the oscillator types due to an excessive amount of false readings.

//Thresholds are no longer Bollinger Bands. Instead, they are calculated using a cumulative average of the oscillator's deviation from 0.

//Minor aesthetic changes.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Updates:

// -> Reorganized script structure.
// -> Main calculations are now expressed as functions.
// -> Added custom threshold inputs.
// -> Added an option to compress the oscillator around thresholds by a specified level of intensity. (Most useful with Fisher Transform oscillator type.)
// -> Revamped color scheme.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Functions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Fisher Transform
fish(x, t) =>
    highval = ta.highest(x, t)
    lowval = ta.lowest(x, t)
    val1 = 0.0
    val1 := 0.66 * ((x - lowval) / math.max(highval - lowval, 0.001) - 0.5) + 0.67 * nz(val1[1], 0)
    val2 = val1 > 0.99 ? 0.999 : val1 < -0.99 ? -0.999 : val1
    fish = 0.0
    fish := 0.5 * math.log((1 + val2) / math.max(1 - val2, 0.001)) + 0.5 * nz(fish[1], 0)
    fish

//Inverse Fisher RSI
ifishrsi(x, t, a) =>
    rsiv = a * (ta.rsi(x, t) - 50)
    wmarv = ta.wma(rsiv, t)
    ifishrsi = (math.exp(2 * wmarv) - 1) / (math.exp(2 * wmarv) + 1)
    ifishrsi

//Inverse Fisher Stochastic
ifishstoch(x, t, a) =>
    stochv = a * (ta.stoch(x, high, low, t) - 50)
    wmasv = ta.wma(stochv, t)
    ifishstoch = (math.exp(2 * wmasv) - 1) / (math.exp(2 * wmasv) + 1)
    ifishstoch

//Inverse Fisher CCI
ifishcci(x, t, a) =>
    cciv = a * ta.cci(x, t)
    wmacv = ta.wma(cciv, t)
    ifishcci = (math.exp(2 * wmacv) - 1) / (math.exp(2 * wmacv) + 1)
    ifishcci

//EMA Function
EMA(x, t) =>
    EMA = x
    EMA := na(EMA[1]) ? x : (x - nz(EMA[1])) * (2 / (t + 1)) + nz(EMA[1])
    EMA

//Cumulative Average Function
cmean(x) =>
    var xsum = 0.0
    xsum := xsum + x
    var tsum = 0.0
    tsum := tsum + 1
    cmean = xsum / tsum
    cmean

//Compression Function
comp(x, k_type, h_knee, l_knee, intensity) =>
    hk = k_type == "Auto" ? cmean(math.abs(x)) : h_knee
    lk = k_type == "Auto" ? -cmean(math.abs(x)) : l_knee
    comp = x > hk ? x - intensity * (x - hk) / 100 : x < lk ? x + intensity * (lk - x) / 100 : x
    comp

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Source
src = input(defval=close, title="Source")

//Sampling Period
per = input.int(defval=13, minval=1, title="Sampling Period")

//Smoothing Inputs
smooth = input(defval=false, title="Smooth Oscillator")
smper = input.int(defval=1, minval=1, title="Smoothing Period")

//Oscillator Type
otype = input.string(defval="Fisher Transform", options=["Fisher Transform", "Inverse Fisher RSI", "Inverse Fisher Stochastic", "Inverse Fisher CCI"], title="Oscillator Type")

//Alpha
alpha = input.float(defval=0.1, minval=0, title="Alpha (for Inverse Fisher Calculations)")

//Threshold Inputs
th_type = input.string(defval="Auto", options=["Auto", "Custom"], title="Threshold Type")
custom_ht = input(defval=0.0, title="Custom High Threshold")
custom_lt = input(defval=0.0, title="Custom Low Threshold")

//Compression Inputs
use_comp = input(defval=false, title="Compress Around Thresholds")
comp_intensity = input.int(defval=90, minval=0, maxval=100, title="Compression Intensity (%)")

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Fisher Transform
fisher = nz(fish(src, per), 0)

//Inverse Fisher RSI
ifrsi = nz(ifishrsi(src, per, alpha), 0)

//Inverse Fisher Stochastic
ifstoch = nz(ifishstoch(src, per, alpha), 0)

//Inverse Fisher CCI
ifcci = nz(ifishcci(src, per, alpha), 0)

//Oscillator Type
osc1 = otype == "Fisher Transform" ? fisher : otype == "Inverse Fisher RSI" ? ifrsi : otype == "Inverse Fisher Stochastic" ? ifstoch : ifcci
osc2 = EMA(osc1, smooth ? smper : 1)
osc = use_comp ? comp(osc2, th_type, custom_ht, custom_lt, comp_intensity) : osc2

//Thresholds
tdist = cmean(math.abs(osc2))
hth = th_type == "Auto" ? tdist : custom_ht
lth = th_type == "Auto" ? -tdist : custom_lt

//Signals
bullpower = osc > 0 and osc >= osc[1] and osc >= hth
bullforming = osc > 0 and osc > osc[1] and osc < hth
bullpullback = osc > 0 and osc < osc[1]
bearpower = osc < 0 and osc <= osc[1] and osc <= lth
bearforming = osc < 0 and osc < osc[1] and osc > lth
bearpullback = osc < 0 and osc > osc[1]

//Color
osccolor = bullforming ? #05fff1 : bullpower ? #05ffa6 : bullpullback ? #00945f : bearforming ? #ff0ae2 : bearpower ? #ff0a70 : bearpullback ? #990040 : #cccccc
basiscolor = osc > 0 ? #00FA9A : osc < 0 ? #C71585 : #cccccc

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Outputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Threshold Plots
hbandplot = plot(hth, color=color.new(#05ffa6, 0), linewidth=1, title="High Threshold")
basisplot = plot(0, color=color.new(basiscolor, 0), linewidth=2, title="Center Threshold")
lbandplot = plot(lth, color=color.new(#ff0a70, 0), linewidth=1, title="Low Threshold")

//Oscillator Plot
oscplot = plot(osc, color=color.new(osccolor, 0), linewidth=2, title="Oscillator")

//Oscillator Fill
fill(oscplot, basisplot, color=color.new(osccolor, 70), title="Oscillator Fill")

//Bar Color
barcolor(osccolor, title="Bar Color")

This file is under the Mozilla Public License 2.0; it is a port of the original by DonovanWall, with the original licence header kept and the changes made for FloScript noted in the file.

• v22026-10-14

  Library refresh 2026-10-14

• v12026-10-12

  Library refresh 2026-10-12