ta

package module
v0.0.0-...-89d38f4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 18, 2023 License: MIT Imports: 5 Imported by: 0

README

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}
Fisher Transform
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
Median
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}
Median Absolute Deviation
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

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Fibnumbers []float64 = []float64{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181}

Functions

func Aad 

func Aad(data []float64, l int) []float64

func Ac 

func Ac(data [][]float64, len1 int, len2 int) []float64

func Alligator 

func Alligator(data []float64, jl int, tl int, ll int, js int, ts int, ls int) [][]float64

func Antimartingale 

func Antimartingale(data []float64, bet float64, max float64, multiplier float64) float64

func Ao 

func Ao(data [][]float64, l1 int, l2 int) []float64

func Ar 

func Ar(data []float64, l int) []float64

func AroonDown 

func AroonDown(data []float64, l int) []float64

func AroonOsc 

func AroonOsc(data []float64, l int) []float64

func AroonUp 

func AroonUp(data []float64, l int) []float64

func Asi 

func Asi(data [][]float64) []float64

func Atr 

func Atr(data [][]float64, l int) []float64

func Avgloss 

func Avgloss(data []float64) float64

func Avgwin 

func Avgwin(data []float64) float64

func Bands 

func Bands(data []float64, l int, dev float64) [][]float64

func Bandwidth 

func Bandwidth(data []float64, l int, dev float64) []float64

func Bop 

func Bop(data [][]float64, l int) []float64

func ChaikinOsc 

func ChaikinOsc(data [][]float64, ema1 int, ema2 int) []float64

func Cop 

func Cop(data []float64, l1 int, l2 int, l3 int) []float64

func Cor 

func Cor(data1 []float64, data2 []float64) float64

func Cum 

func Cum(data []float64, l int) []float64

func Cwma 

func Cwma(data []float64, weights []float64) []float64

func Denormalize 

func Denormalize(norm []float64, data []float64, m float64) []float64

func Dif 

func Dif(n float64, o float64) float64

func Divergence 

func Divergence(data1 []float64, data2 []float64) []float64

func Don 

func Don(data [][]float64, l int) [][]float64

func Drawdown 

func Drawdown(data []float64) float64

func Elderray 

func Elderray(data []float64, l int) [][]float64

func Ema 

func Ema(data []float64, l int) []float64

func Envelope 

func Envelope(data []float64, l int, p float64) [][]float64

func Er 

func Er(data []float64) float64

func Exp 

func Exp(data []float64) []float64

func Fi 

func Fi(data [][]float64, l int) []float64

func Fib 

func Fib(start float64, end float64) []float64

func Fibbands 

func Fibbands(data [][]float64, length int, deviations float64) [][]float64

func Fisher 

func Fisher(data []float64, l int) [][]float64

func Fractals 

func Fractals(data [][]float64) [][]bool

func Gator 

func Gator(data []float64, jl int, tl int, ll int, js int, ts int, ls int) [][]float64

func Ha 

func Ha(data [][]float64) [][]float64

func HalfTrend 

func HalfTrend(data [][]float64, atrlen int, amplitude int, deviation float64) [][]interface{}

func Hull 

func Hull(data []float64, l int) []float64

func Hv 

func Hv(data []float64, l int) []float64

func Hwma 

func Hwma(data []float64, l int) []float64

func Ichimoku 

func Ichimoku(data [][]float64, l1 int, l2 int, l3 int, l4 int) [][]float64

func Kama 

func Kama(data []float64, l1 int, l2 int, l3 int) []float64

func Kelly 

func Kelly(data []float64) float64

func Keltner 

func Keltner(data [][]float64, l int, dev float64) [][]float64

func Kmeans 

func Kmeans(data []float64, clusters int) [][]float64

func Kst 

func Kst(data []float64, r1 int, r2 int, r3 int, r4 int, s1 int, s2 int, s3 int, s4 int, sig int) [][]float64

func Line 

func Line(index int, slope float64, value float64) line

func LineCalc 

func LineCalc(pos int, calc line) float64

func Log 

func Log(data []float64) []float64

func LossAverage 

func LossAverage(data []float64) float64

func Lsma 

func Lsma(data []float64, l int) []float64

func Macd 

func Macd(data []float64, l1 int, l2 int) []float64

func Mad 

func Mad(data []float64, l int) []float64

func Martingale 

func Martingale(data []float64, bet float64, max float64, multiplier float64) float64

func Median 

func Median(data []float64, l int) []float64

func Mfi 

func Mfi(data [][]float64, l int) []float64

func Mom 

func Mom(data []float64, l int, p bool) []float64

func MomOsc 

func MomOsc(data []float64, l int) []float64

func Mse 

func Mse(data1 []float64, data2 []float64) float64

func Ncdf 

func Ncdf(x float64, mean float64, std float64) float64

func Normalize 

func Normalize(data []float64, m float64) []float64

func NormalizeFrom 

func NormalizeFrom(data []float64, value float64) []float64

func NormalizePair 

func NormalizePair(data1 []float64, data2 []float64) [][]float64

func Normsinv 

func Normsinv(p float64) float64

func Obv 

func Obv(data [][]float64) []float64

func Percentile 

func Percentile(data [][]float64, perc float64) []float64

func Permutations 

func Permutations(data []float64) float64

func Pr 

func Pr(data []float64, l int) []float64

func Psar 

func Psar(data [][]float64, step float64, max float64) []float64

func Pvalue 

func Pvalue(t float64, df int) float64

func Pwma 

func Pwma(data []float64, l int) []float64

func RecentHigh 

func RecentHigh(data []float64, lb int) recentHighLow

func RecentHighLow 

func RecentHighLow(index int, value float64) recentHighLow

func RecentLow 

func RecentLow(data []float64, lb int) recentHighLow

func Ren 

func Ren(data [][]float64, bs float64) [][]float64

func Resistance 

func Resistance(d []float64, hl recentHighLow) line

func Roc 

func Roc(data []float64, l int) []float64

func Rsi 

func Rsi(data []float64, l int) []float64

func Rsi_divergence 

func Rsi_divergence(data []float64, ln int, rs func([]float64, int) []float64) []float64

func Rvi 

func Rvi(data [][]float64, ln int) []float64

func Rvi_signal 

func Rvi_signal(rv []float64) []float64

func Se 

func Se(data []float64, l int) float64

func Sim 

func Sim(data []float64, l int, sims int) [][]float64

func Sma 

func Sma(data []float64, l int) []float64

func Smma 

func Smma(data []float64, l int) []float64

func Ssd 

func Ssd(data []float64, l int) []float64

func Standardize 

func Standardize(data []float64) []float64

func Std 

func Std(data []float64, l int) float64

func Stoch 

func Stoch(data [][]float64, l int, sd int, sk int) [][]float64

func Sum 

func Sum(data []float64) float64

func Supertrend 

func Supertrend(data [][]float64, l int, multiplier float64) [][]float64

func Support 

func Support(d []float64, hl recentHighLow) line

func Times_down 

func Times_down(data []float64, l int) []float64

func Times_up 

func Times_up(data []float64, l int) []float64

func Tsi 

func Tsi(data []float64, llen int, slen int, sig int) [][]float64

func Variance 

func Variance(data []float64, l int) []float64

func Vwap 

func Vwap(data [][]float64, l int) []float64

func Vwma 

func Vwma(data [][]float64, l int) []float64

func Vwwma 

func Vwwma(data [][]float64, l int) []float64

func WinAverage 

func WinAverage(data []float64) float64

func Winratio 

func Winratio(data []float64) float64

func Wma 

func Wma(data []float64, l int) []float64

func Wrsi 

func Wrsi(data []float64, l int) []float64

func Wsma 

func Wsma(data []float64, l int) []float64

func ZigZag 

func ZigZag(data [][]float64, perc float64) []float64

func Zscore 

func Zscore(data []float64, l int) []float64

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.