LAMA-based Strategy

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

//@version=4
study("LAMA-based Strategy", '', true)

// Log-Normal Moving Average (LAMA)

// The Log-Normal Moving Average (LAMA) is the name given to 
// an Adaptive Moving Average that uses the adaptive process 
// developed by John F Ehlers for use in his FRAMA.  
// Stock prices are said to be Log-Normal so Ehlers used EXP 
// to relate his Volatility Index (The Fractal Dimension) to Alpha.  
// The LAMA is designed so that any VIX can easily be incorporated 
// as long as it shifts between a range of 1 – 0 where high readings 
// indicate high volatility.

// Formula:
// LAMA = LAMA(1) + New α * (Close – LAMA(1))
// where:
//    New α = 2 / (New N + 1)
//    New N = ((SC – FC) * ((N – 1) / (SC – 1))) + FC
//    SC = Your choice of a Slow moving average > FC
//    FC = Your choice of a Fast moving average < SC
//    N = (2 – α) / α
//    α = EXP(W * (1 – VIX))
//    W = LN(2 / (SC + 1))

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

ds        = input(close, 'Dataset')
prim      = input(3,     'Primary Lag |1..n|',    minval=1)
sec       = input(2,     'Secondary Lag |1..n|',  minval=1)
ftype     = input('Both','Filter Signals by',     options=['Volatility','Volume','Both','None'])
holding_p = input(1,     'Holding Period |1..n|', minval=1)
showma    = input(false, 'Show MAs?')

//-------------------- System Variables

var BUY  = -1 
var SELL =  1 
var HOLD =  0

//--------------------  Dynamic Arrays

var int   signal     = HOLD
var float maf        = 0.0
var float mas        = 0.0
var int   hp_counter = 0

//-------------------- Custom Functions

volumeBreak(thres) =>  
    rsivol   = rsi(volume, 14)  
    osc      = hma(rsivol, 10)  
    osc > thres                     

volatilityBreak(volmin, volmax) => atr(volmin) > atr(volmax)

lama(ds, prim, sec) =>
    vix   = 100 * abs(high - low) / close  // volatility index
    W     = log(2 / (sec + 1))
    a     = exp(W * (1 - vix))
    N     = (2 - a) / a
    New_N = ((sec - prim) * ((N - 1) / (sec - 1))) + prim
    New_a = 2 / (New_N + 1)
    var float lama = 0.0
    lama := nz(lama[1]) + New_a * (ds - nz(lama[1]))

//-------------------- Logic

filter =   ftype=='Volatility' ? volatilityBreak(1, 10) 
         : ftype=='Volume'     ? volumeBreak(49) 
         : ftype=='Both'       ? volatilityBreak(1, 10) and volumeBreak(49)
         :                       true

lama1 = lama(ds, prim, sec)
lama2 = lama(lama1, prim, prim+2)
    
// Generate signal

signal :=  lama1 > lama2 and filter ? BUY : lama1 < lama2 and filter ? SELL : nz(signal[1]) 

changed = change(signal)

hp_counter := changed ? 0 : hp_counter + 1

startLongTrade  = changed and signal==BUY    
startShortTrade = changed and signal==SELL   
endLongTrade    = (changed and signal==SELL) or (signal==BUY  and hp_counter==holding_p and not changed) 
endShortTrade   = (changed and signal==BUY)  or (signal==SELL and hp_counter==holding_p and not changed) 

//-------------------- Rendering

plot(showma ? lama1 : na, '', color.orange)
plot(showma ? lama2 : na, '', color.blue)

plotshape(startLongTrade  ? low  : na, 'Buy',  shape.labelup,   location.belowbar, color.blue, 30, size=size.tiny, text='lm', textcolor=color.white)
plotshape(startShortTrade ? high : na, 'Sell', shape.labeldown, location.abovebar, color.red,  30, size=size.tiny, text='lm', textcolor=color.white)
plot(endLongTrade         ? high : na, 'StopBuy',  color.blue, 2, plot.style_cross)
plot(endShortTrade        ? low  : na, 'StopSell', color.red,  2, plot.style_cross)

//-------------------- Notification

if changed and signal==BUY 
    alert("Buy Alert", alert.freq_once_per_bar)  // alert.freq_once_per_bar_close
if changed and signal==SELL 
    alert("Sell Alert", alert.freq_once_per_bar)
    
alertcondition(startLongTrade,  "Buy Alert",  "Go Long!")
alertcondition(startShortTrade, "Sell Alert", "Go Short!") 

//-------------------- Backtesting

show_info = input(true, '===Backtesting Results===')
lot_size  = input(0.01,  'Lot Size', options=[0.01,0.1,0.2,0.3,0.5,1,2,3,5,10,20,30,50,100,1000]) 
useopen   = input(true,  'Open Price=true, OHL3=false')

tbase   = (time - time[1]) / 1000
tcurr   = (timenow - time_close[1]) / 1000
barlife = tcurr / tbase

bidask  = useopen ? open : (open+high+low)/3

var float start_long_trade  = bidask  
var float long_trades       = 0.
var float start_short_trade = bidask  
var float short_trades      = 0.
var int   wins              = 0
var int   trade_count       = 0

if startLongTrade 
    start_long_trade := bidask 
if endLongTrade
    ldiff         = (bidask - start_long_trade)
    wins         := ldiff > 0 ? 1 : 0
    long_trades  := ldiff * lot_size   
    trade_count  := 1
if startShortTrade 
    start_short_trade := bidask
if endShortTrade
    sdiff         = (start_short_trade - bidask)
    wins         := sdiff > 0 ? 1 : 0
    short_trades := sdiff * lot_size 
    trade_count  := 1
    
cumreturn   = cum(long_trades) + cum(short_trades)  //-- cumulative return 
totaltrades = cum(trade_count)
totalwins   = cum(wins)  
totallosses = totaltrades - totalwins == 0 ? 1 : totaltrades - totalwins

//------------------- Information

var label lbl = na

info =  'CR='          + tostring(cumreturn,             '#.#') 
      + '\nTrades: '   + tostring(totaltrades,           '#')
      + '\nWin/Loss: ' + tostring(totalwins/totallosses, '#.##') 
      + '\nWinrate: '  + tostring(totalwins/totaltrades, '#.#%')       
      + '\nBar Time: ' + tostring(barlife,               '#.#%')

if show_info and barstate.islast  
    lbl := label.new(bar_index, ohlc4, info, xloc.bar_index, yloc.price, 
                     color.new(color.blue, 100), label.style_label_left, color.black, size.small, text.align_left)
    label.delete(lbl[1])