Technical Analysis (ta.go)
ta.go is a go module for dealing with financial technical analysis.
Installation
go get github.com/Bitvested/ta.go@latest
Usage
import(
ta "github.com/Bitvested/ta.go"
)
Examples
Moving Averages
Indicators
Oscillators
Bands
Statistics
Chart Types
Miscellaneous
Experimental
Simple Moving Average (SMA)
data := []float64{1, 2, 3, 4, 5, 6, 10};
length := 6;
ta.Sma(data, length);
// output []float64
// {3.5, 5}
Smoothed Moving Average (SMMA)
data := []float64{1, 2, 3, 4, 5, 6, 10};
length := 5;
ta.Smma(data, length);
// output []float64
// {3.4, 4.92}
Weighted Moving Average (WMA)
data := []float64{69, 68, 66, 70, 68};
length := 4;
ta.Wma(data, length);
// output []float64
// {68.3, 68.2}
Exponential Moving Average (EMA)
data := []float64{1, 2, 3, 4, 5, 6, 10};
length := 6;
ta.Ema(data, length);
// output []float64
// {3.5, 5.357}
Hull Moving Average
data := []float64{6, 7, 5, 6, 7, 4, 5, 7};
length := 6;
ta.Hull(data, length);
// output []float64
// {4.76, 5.48}
Least Squares Moving Average (LSMA)
data := []float64{5, 6, 6, 3, 4, 6, 7};
length := 6;
ta.Lsma(data, length);
// output []float64
// {4.714, 5.761}
Volume Weighted Moving Average (VWMA)
data := [][]float64{{1, 59}, {1.1, 82}, {1.21, 27}, {1.42, 73}, {1.32, 42}}; // {price, volume (quantity)}
length := 4;
ta.Vwma(data, length);
// output []float64
// {1.185, 1.259}
Volume Weighted Weighted Moving Average (VWWMA)
data := [][]float64{{1, 59}, {1.1, 82}, {1.21, 27}, {1.42, 73}, {1.32, 42}}; // {price, volume}
length := 4;
ta.Vwwma(data, length);
// output []float64
// {1.262, 1.316}
Wilder's Smoothing Moving Average
data := []float64{1, 2, 3, 4, 5, 6, 10};
length := 6;
ta.Wsma(data, length);
// output []float64
// {3.5, 4.58}
Parabolic Weighted Moving Average
data := []float64{17, 26, 23, 29, 20};
length := 4;
ta.Pwma(data, length);
// output []float64
// {24.09, 25.18}
Hyperbolic Weighted Moving Average
data := []float64{54, 51, 86, 42, 47};
length := 4;
ta.Hwma(data, length);
// output []float64
// {56.2, 55.0}
Kaufman Adaptive Moving Average (KAMA)
data := []float64{8, 7, 8, 9, 7, 9};
length1 := 2;
length2 := 4;
length3 := 8;
ta.Kama(data, length1, length2, length3);
// output []float64
// {8, 8.64, 8.57, 8.57}
Custom Weighted Moving Average
data := []float64{69,68,66,70,68,69};
weights := []float64{1,2,3,5,8};
ta.Cwma(data, weights);
// output []float64
// {68.26315789473684, 68.52631578947368}
Moving Average Convergence / Divergence (MACD)
data := []float64{1, 2, 3, 4, 5, 6, 14};
length1 := 3;
length2 := 6;
ta.Macd(data, length1, length2);
// output []float64
// {1.5, 3}
Relative Strength Index (RSI)
data := []float64{1, 2, 3, 4, 5, 6, 7, 5};
length := 6;
ta.Rsi(data, length);
// output []float64
// {100.0, 100.0, 66.667}
Wilder's Relative Strength Index
data := []float64{1, 2, 3, 4, 5, 6, 7, 5, 6};
length := 6;
ta.Wrsi(data, length);
// output []float64
// {100, 71.43, 75.61}
True Strength Index (TSI)
data := []float64{1.32, 1.27, 1.42, 1.47, 1.42, 1.45, 1.59};
longlength := 3;
shortlength := 2;
signallength := 2;
ta.Tsi(data, longlength, shortlength, signallength);
// output [][]float64
// {{0.327, 0.320}, {0.579, 0.706}}
// {strength line, signal line}
Balance Of Power
data := [][]float64{{4, 5, 4, 5}, {5, 6, 5, 6}, {6, 8, 5, 6}}; // {open, high, low, close}
length := 2;
ta.Bop(data, length);
// output []float64
// {1, 0.5}
Force Index
data := [][]float64{{1.4, 200}, {1.5, 240}, {1.1, 300}, {1.2, 240}, {1.5, 400}}; // {close, volume}
length := 4;
ta.Fi(data, length);
// output []float64
// {0.0075}
Accumulative Swing Index
data := [][]float64{{7, 6, 4}, {9, 7, 5}, {9, 8, 6}}; // {high, close, low}
ta.Asi(data);
// output []float64
// {0, -12.5}
Alligator Indicator
data := []float64{8,7,8,9,7,8,9,6,7,8,6,8,10,8,7,9,8,7,9,6,7,9};
jawlength := 13;
teethlength := 8;
lipslength := 5;
jawshift := 8;
teethshift := 5;
lipshift := 3;
ta.Alligator(data, jawlength, teethlength, liplength, jawshift, teethshift, lipshift);
// output [][]float64
// {{jaw, teeth, lips}}
Williams %R
data := []float64{2, 1, 3, 1, 2};
length := 4;
ta.Pr(data, length);
// output []float64
// {-0, -100, -50}
Stochastics
data := [][]float64{{3,2,1}, {2,2,1}, {4,3,1}, {2,2,1}}; // {high, close, low}
length := 2;
smoothd := 1;
smoothk := 1;
ta.Stoch(data, length, smoothd, smoothk);
// output []float64
// {{66.667, 66.667}, {33.336, 33.336}}
// {{kline, dline}}
Fibonacci Retracement
start := 1;
end := 2;
ta.Fib(start, end);
// output []float64
// {1, 1.236, 1.382, 1.5, 1.618, 1.786, 2, 2.618, 3.618, 4.618, 5.236}
Bollinger Bandwidth
data := []float64{1, 2, 3, 4, 5, 6};
length := 5;
deviations := 2;
ta.Bandwidth(data, length, deviations);
// output []float64
// {1.886, 1.344}
Ichimoku Cloud
data := [][]float64{{6, 3, 2}, {5, 4, 2}, {5, 4, 3}, {6, 4, 3}, {7, 6, 4}, {6, 5, 3}}; // {high, close, low}
length1 := 9;
length2 := 26;
length3 := 52;
displacement := 26;
ta.Ichimoku(data, length1, length2, length3, displacement);
// output []float64
// {conversion line, base line, leading span A, leading span B, lagging span}
Average True Range (ATR)
data := [][]float64{{3,2,1}, {2,2,1}, {4,3,1}, {2,2,1}}; // {high, close, low}
length := 3;
ta.Atr(data, length);
// output []float64
// {2, 1.667, 2.111, 1.741}
Aroon Up
data := []float64{5, 4, 5, 2};
length := 3;
ta.AroonUp(data, length);
// output []float64
// {100, 50}
Aroon Down
data := []float64{2, 5, 4, 5};
length := 3;
ta.AroonDown(data, length);
// output []float64
// {0, 50}
Money Flow Index
data := [][]float64{{19, 13}, {14, 38}, {21, 25}, {32, 17}}; // {buy volume, sell volume}
length := 3;
ta.Mfi(data, length);
// output []float64
// {41.54, 45.58}
Rate Of Change
data := []float64{1, 2, 3, 4};
length := 3;
ta.Roc(data, length);
// output []float64
// {2, 1}
Coppock Curve
data := []float64{3, 4, 5, 3, 4, 5, 6, 4, 7, 5, 4, 7, 5};
length1 := 4;
length2 := 6;
length3 := 5;
ta.Cop(data, length1, length2, length3);
// output []float64
// {0.376, 0.237}
Know Sure Thing
data := []float64{8, 6, 7, 6, 8, 9, 7, 5, 6, 7, 6, 8, 6, 7, 6, 8, 9, 9, 8, 6, 4, 6, 5, 6, 7, 8, 9};
// roc sma #1
r1 := 5;
s1 := 5;
// roc sma #2
r2 := 7;
s2 := 5;
// roc sma #3
r3 := 10;
s3 := 5;
// roc sma #4
r4 := 15;
s4 := 7;
// signal line
sig := 4;
ta.Kst(data, r1, r2, r3, r4, s1, s2, s3, s4, sig);
// output []float64
// {{-0.68, -0.52}, {-0.29, -0.58}, {0.35, -0.36}}
// {kst line, signal line}
On-Balance Volume
data := [][]float64{{25200, 10}, {30000, 10.15}, {25600, 10.17}, {32000, 10.13}}; // {asset volume, close price}
ta.Obv(data);
// output []float64
// {0, 30000, 55600, 23600}
Volume-Weighted Average Price
data := [][]float64{{127.21, 89329}, {127.17, 16137}, {127.16, 23945}}; // {average price, volume (quantity)}
length := 2;
ta.Vwap(data, length);
// output []float64
// {127.204, 127.164}
Fractals
data := [][]float64{{7,6},{8,6},{9,6},{8,5},{7,4},{6,3},{7,4},{8,5}};
ta.Fractals(data);
// output [][]float64 (same length as input)
// {{false, false},{false,false},{true,false},{false,false},{false,false},{false,true},{false,false},{false,false}}
// {upper fractal, lower fractal}
Momentum
data := []float64{1, 1.1, 1.2, 1.24, 1.34};
length := 4;
percentage := false;
ta.Mom(data, length, percentage);
// output []float64
// {0.24, 0.24}
HalfTrend
// experimental (untested) function (may change in the future), ported from:
// https://www.tradingview.com/script/U1SJ8ubc-HalfTrend/
// data = [high, close, low]
data := [][]float64{{100,97,90},{101,98,94},{103,96,92},{106,100,95},{110,101,100},{112,110,105},{110,100,90},{103,100,97},{95,90,85},{94,80,80},{90,82,81},{85,80,70}};
atrlen := 6;
amplitude := 3;
deviation := 2;
ta.HalfTrend(data, atrlen, amplitude, deviation);
// output [][]interface{}
// {high, halftrend, low, signal}
ZigZag
data := [][]float64{[]float64{10,9},[]float64{12,10},[]float64{14,12},[]float64{15,13},[]float64{16,15},[]float64{11,10},[]float64{18,15}};
percentage := 0.25;
ta.ZigZag(data, percentage);
// output []float64
// []float64{9, 10.75, 12.5, 14.25, 16, 10, 18}
Parabolic SAR
data := [][]float64{[]float64{82.15,81.29},[]float64{81.89,80.64},[]float64{83.03,81.31},[]float64{83.30,82.65},[]float64{83.85,83.07},[]float64{83.90,83.11},[]float64{83.33,82.49},[]float64{84.30,82.3},[]float64{84.84,84.15},[]float64{85,84.11},[]float64{75.9,74.03},[]float64{76.58,75.39},[]float64{76.98,75.76},[]float64{78,77.17},[]float64{70.87,70.01}}
step := 0.02;
max := 0.2;
ta.Psar(data, step, max);
// output []float64{}
// []float64{81.29,82.15,80.64,80.64,80.7464,80.932616,81.17000672,81.3884061824,81.67956556416,82.0588176964608,85,85,84.7806,84.565588,84.35487624000001}
SuperTrend
data := [][]float64{{3,2,1},{2,2,1},{4,3,1},{2,2,1}}; // {high, close, low}
length := 3;
multiplier := 0.5;
ta.Supertrend(data, length, multiplier);
// output [][]float64{}
// {{5.56, 1.44}, {3.37, 0.63}}
// {up, down}
Elder Ray Index
data := []float64{6,5,4,7,8,9,6,8};
length := 7;
ta.Elderray(data, length);
// output []float64
// {{2.57,-2.43},{2.29,-2.71}}
// {bull, bear}
Historical Volatility
data := []float64{7,6,5,7,8,9,7,6,5};
length := 8;
ta.Hv(data, length);
// output []float64
// {0.642, 0.682}
Relative Vigor Index
// data = [[open,high,low,close]] (requires at least 4 + length values)
data := [][]float64{{4,6,3,3}, {3,5,2,2}, {2,5,2,4}, {4,6,4,5}, {5,7,4,4}, {4,6,3,4}, {4,7,3,5}, {5,7,5,6}, {6,8,6,6}, {6,9,5,6}, {6,8,6,7}, {7,9,5,6},{6,7,4,5},{5,6,5,6},{6,8,5,5},{5,7,2,6}};
length := 8;
ta.Rvi(data, length);
// output []float64
// {0.29,0.21,0.15,0.16,0.09,0.05}
Relative Vigor Index Signal
rvi := []float64{0.29,0.21,0.15,0.16,0.09,0.05}; // requires at least 4 values
ta.Rvi_signal(rvi);
// output []float64
// {0.20,0.15,0.12}
RSI Divergence
Experimental function: https://github.com/Bitvested/ta.js/issues/18
data := []float64{74,83,66,78,69,70,84,73,74,73,83};
rsi_length := 5;
rsi_function := ta.Wrsi; // The tradingview RSI
ta.Rsi_divergence(data, rsi_length, rsi_function);
// output []float64
// 1 = RSI is in divergence
// 0 = RSI is not in divergence
// [0, 0, 1, 0, 1, 0] (better to quantify if needed)
Universal Divergence
data1 := []float64{48,34,43,54,56,64,43};
data2 := []float64{76,74,43,55,34,32,45,47};
ta.Divergence(data1, data2);
// output []float64]
// 1 = RSI is in divergence
// 0 = RSI is not in divergence
// [0, 0, 1, 1, 0, 1] (better to quantify if needed)
Oscillators
Alligator Oscillator
data := []float64{8,7,8,9,7,8,9,6,7,8,6,8,10,8,7,9,8,7,9,6,7,9}
jawlength := 13;
teethlength := 8;
liplength := 5;
jawshift := 8;
teethshift := 5;
lipshift := 3;
ta.Gator(data, jawlength, teethlength, liplength, jawshift, teethshift, lipshift);
// output [][]float64
// {{upper gator, lower gator}}
Chande Momentum Oscillator
data := []float64{1, 1.2, 1.3, 1.3, 1.2, 1.4};
length := 4;
ta.MomOsc(data, length);
// output []float64
// {0, 3.85}
Chaikin Oscillator
data := [][]float64{{2,3,4,6},{5,5,5,4},{5,4,3,7},{4,3,3,4},{6,5,4,6},{7,4,3,6}}
length1 := 2;
length2 := 4;
ta.ChaikinOsc(data, length1, length2);
// output []float64
// {-1.667, -0.289, -0.736}
Aroon Oscillator
data := []float64{2, 5, 4, 5};
length := 3;
ta.AroonOsc(data, length);
// output []float64
// {50, 50}
Awesome Oscillator
data := [][]float64{{6, 5}, {8, 6}, {7, 4}, {6, 5}, {7, 6}, {9, 8}}; // {high, low}
shortlength := 2;
longlength := 5;
ta.Ao(data, shortlength, longlength);
// output []float64
// {0, 0.9}
Accelerator Oscillator
data := [][]float64{{6, 5}, {8, 6}, {7, 4}, {6, 5}, {7, 6}, {9, 8}};
shortlength := 2;
longlength := 4;
ta.Ac(data, shortlength, longlength);
// output []float64
// {-5.875, -6.125, -6.5}
data := []float64{8,6,8,9,7,8,9,8,7,8,6,7};
length := 9;
ta.Fisher(data, length);
// output [][]float64
// {{-0.318, -0.11}, {-0.449, -0.318}, {-0.616, -0.449}} // [fisher, trigger]
Bands
Bollinger Bands
data := []float64{1, 2, 3, 4, 5, 6};
length := 5;
deviations := 2;
ta.Bands(data, length, deviations);
// output []float64
// {{5.828, 3, 0.172}, {6.828, 4, 1.172}}
// {upper band, middle band, lower band}
Keltner Channels
data := [][]float64{{3,2,1}, {2,2,1}, {4,3,1}, {2,2,1}, {3,3,1}}; // {high, close, low}
length := 5;
deviations := 1;
ta.Keltner(data, length, deviations);
// output [][]float64
// {{3.93, 2.06, 0.20}}
// {upper band, middle band, lower band}
Donchian Channels
data := [][]float64{{6, 2}, {5, 2}, {5, 3}, {6, 3}, {7, 4}, {6, 3}}; // {high, low}
length := 5;
ta.Don(data, length);
// output []float64
// {{7, 4.5, 2}, {7, 4.5, 2}}
// {upper band, base line, lower band}
Fibonacci Bollinger Bands
// created from: https://tradingview.com/script/qIKR3tbN-Fibonacci-Bollinger-Bands/
data := [][]float64{{1, 59}, {1.1, 82}, {1.21, 27}, {1.42, 73}, {1.32, 42}};
length := 4; // default = 20
deviations := 3; // default = 3
ta.Fibbands(data, length, deviations);
// output []float64
// {{upper band -> fibonacci levels -> lower band}}
Envelope
data := []float64{6,7,8,7,6,7,8,7,8,7,8,7,8};
length := 11;
percentage := 0.05;
ta.Envelope(data, length, percentage);
// output [][]float64
// {{7.541, 7.182, 6.823}, {7.636, 7.273, 6.909}}
// {upper band, base line, lower band}
Statistics
Sum
data := []float64{1,2,3};
ta.Sum(data);
// output (float64)
// 6
Standard Deviation
data := []float64{1, 2, 3};
length := 3;
ta.Std(data, length);
// output float64
// 0.81649658092773
Variance
data := []float64{6, 7, 2, 3, 5, 8, 6, 2};
length := 7;
ta.Variance(data, length);
// output []float64
// {3.918, 5.061}
Normal CDF
sample := 13;
mean := 10;
stdv := 2;
ta.Ncdf(sample, mean, stdv);
// output float64
// 0.9331737996110652
Inverse Normal Distribution
data := 0.4732;
ta.Normsinv(data);
// output float64
// -0.06722824471054376
Monte Carlo Simulation
data := []float64{6, 4, 7};
length := 2;
simulations := 2;
ta.Sim(data, length, simulations);
// output [][]float64
// [6, 4, 7, 8, 5, 6, 5.96, 5.7]
Percentile
data := [][]float64{{6, 4, 7}, {5, 3, 6}, {7, 5, 8}};
percentile := 0.5;
ta.Percentile(data, percentile);
// output []float64
// {5, 3, 6}
Correlation
data1 := []float64{1, 2, 3, 4, 5, 2};
data2 := []float64{1, 3, 2, 4, 6, 3};
ta.Cor(data1, data2);
// output float64
// 0.8808929232684737
Percentage Difference
newval := 0.75;
oldval := 0.5;
ta.Dif(newval, oldval);
// output float64
// 0.5
Expected Return
data := []float64{0.02, -0.01, 0.03, 0.05, -0.03}; // historical return data
ta.Er(data);
// output float64
// 0.0119
Abnormal Return
data := []float64{0.02, -0.01, 0.03, 0.05, -0.03}; // historical return data
length := 3;
ta.Ar(data, length);
// output float64
// [0.037, -0.053]
Kelly Criterion
data := []float64{0.01, 0.02, -0.01, -0.03, -0.015, 0.045, 0.005};
ta.Kelly(data);
// output float64
// 0.1443
Martingale
data := []float64{-1,1,1,1,-1,-1};
var bet float64 = 5;
var max float64 = 20;
var multiplier float64 = 2;
ta.Martingale(data, bet, max, multiplier)
// output float64
// 20
Anti-Martingale
data := []float64{1,1,-1,-1,1,1};
var bet float64 = 5;
var max float64 = 20;
var multiplier float64 = 2;
ta.Antimartingale(data, bet, max, multiplier);
// output float64
// 20
Permutations
data := []float64{10,10,10};
ta.Permutations(data);
// output float64
// 1000
Winratio
data := []float64{0.01, 0.02, -0.01, -0.03, -0.015, 0.005};
ta.Winratio(data);
// output float64
// 0.5
Average Win
data := []float64{0.01, 0.02, -0.01, -0.03, -0.015, 0.005};
ta.Avgwin(data);
// output float64
// 0.012
Average Loss
data := []float64{0.01, 0.02, -0.01, -0.03, -0.015, 0.005};
ta.Avgloss(data);
// output float64
// -0.018
Drawdown
data := []float64{1, 2, 3, 4, 2, 3};
ta.Drawdown(data);
// output float64
// -0.5
data := []float64{4, 6, 3, 1, 2, 5};
length := 4;
ta.Median(data, length);
// output []float64
// {3, 2, 2}
Recent High
data := []float64{4,5,6,7,8,9,8,7,8,9,10,3,2,1};
lookback := 3;
ta.RecentHigh(data, lookback);
// output (struct)
// {Index: int, Value: float64}
Recent High
data := []float64{1,4,5,6,4,3,2,3,4,3,5,7,8,8,5};
lookback := 3;
ta.RecentLow(data, lookback);
// output (struct)
// {Index: int, Value: float64}
data := []float64{3, 7, 5, 4, 3, 8, 9};
length := 6;
ta.Mad(data, length);
// output []float64
// {1, 2}
Average Absolute Deviation
data := []float64{4, 6, 8, 6, 8, 9, 10, 11};
length := 7;
ta.Aad(data, length);
// output []float64
// {1.673, 1.468}
Standard Error
data := []float64{34, 54, 45, 43, 57, 38, 49};
size := 10;
ta.Se(data, size);
// output float64
// 2.424
Sum Squared Differences
data := []float64{7, 6, 5, 7, 9, 8, 3, 5, 4};
length := 7;
ta.Ssd(data, length);
// output []float64
// {4.87, 4.986, 5.372}
Logarithm
data := []float64{5, 14, 18, 28, 68, 103};
ta.Log(data);
// output []float64
// {1.61, 2.64, 2.89, 3.33, 4.22, 4.63}
Exponent
data := []float64{1.6, 2.63, 2.89, 3.33, 4.22, 4.63};
ta.Exp(data);
// output []float64
// {4.95, 13.87, 17.99, 27.94, 68.03, 102.51}
Normalize
data := []float64{5,4,9,4};
margin := 0.1;
ta.Normalize(data, margin);
// output []float64
// {0.22, 0.06, 0.86, 0.06}
Denormalize
data := []float64{5,4,9,4}; // original data || {highest, lowest}
norm := float64{0.22, 0.06, 0.86, 0.06, 0.44};
margin := 0.1;
ta.Denormalize(data, norm, margin);
// output []float64
// {5 ,4, 9, 4, 6.4}
Normalize Pair
pair1 := []float64{10,12,11,13};
pair2 := []float64{100,130,100,140};
ta.NormalizePair(pair1, pair2);
// output [][]float64
// [[55, 55], [66, 71.5], [60.5, 54.99], [71.5, 76.99]]
Normalize From
data := []float64{8,12,10,11};
baseline := 100;
// output []float64
// [100, 150, 125, 137.5]
Standardize
data := []float64{6,4,6,8,6};
ta.Standardize(data);
// output []float64
// {0, -1.581, 0, 1.581, 0}
Z-Score
data := []float64{34,54,45,43,57,38,49};
length := 5;
ta.Zscore(data, length);
// output []float64
// [1.266, -1.331, 0.408]
P-Value
t_stat := 2.0;
df := 4;
ta.Pvalue(t_stat, df);
// output float64
// 0.075
K-means Clustering
data := []float64{2, 3, 4, 5, 3, 5, 7, 8, 6, 8, 6, 4, 2, 6};
length := 4;
ta.Kmeans(data, length);
// output [][]float64
// {{ 4, 5, 5, 4 }, { 7, 6, 6, 6 }, { 8, 8 }, { 2, 3, 3, 2 }}
Mean Squared Error
data1 := []float64{7,8,7,8,6,9};
data2 := []float64{6,8,8,9,6,8};
ta.Mse(data1, data2);
// output float64
// 0.6666666666666666
Cumulative
data := []float64{3,5,7,5,10};
length := 4;
ta.Cum(data, length);
// output float64
// []float64{ 20, 27 }
Chart Types
Heikin Ashi
data := [][]float64{{3, 4, 2, 3}, {3, 6, 3, 5}, {5, 5, 2, 3}}; // {open, high, low, close}
ta.Ha(data);
// output []float64
// {open, high, low, close}
// first 7-10 candles are unreliable
Renko
data := [][]float64{{8, 6}, {9, 7}, {9, 8}}; // {high, low}
bricksize := 3;
ta.Ren(data, bricksize);
// output []float64
// {open, high, low, close}
Miscellaneous
Fibonacci Sequence
ta.Fibnumbers;
// output []float64{}
// {0, 1, 1, 2, 3, 5, 8...}
Times Up
data := []float64{5,6,7,8,7,6,5};
l := 3;
ta.Times_up(data, length);
// output []float64{}
// {1, 0, 0, 0}
Times Down
data := []float64{5,6,7,8,7,6,5};
l := 3;
ta.Times_down(data, l);
// output []float64{}
// {0, 0, 0, 1}
Experimental Functions
Support Line
data := []float64{4,3,2,5,7,6,5,4,7,8,5,4,6,7,5};
start := ta.RecentLow(data, 20);
support := ta.Support(data, start);
// output (struct) {Slope, Value, Index}
// support.Slope = delta y per x
// support.Lowest = lowest (start) value at x = 0
// support.Index = (start) index of the lowest value
// to get the line at the current candle / chart period
current := ta.LineCalc(len(data)-support.Index, support);
Resistance Line
data := []float64{5,7,5,5,4,6,5,4,6,5,4,3,2,4,3,2,1};
start := ta.RecentHigh(data, 20);
resistance := ta.Resistance(data, start);
// output (struct) {Slope, Value, Index}
// resistance.Slope = delta y per x
// resistance.Highest = highest (start) value
// resistance.Index = (start) index of highest value
// to get the line at the current candle / chart period
current := ta.LineCalc(len(data)-resistance.Index, resistance);
Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Please make sure to update tests as appropriate.
License
MIT