Skip to content

Bitvested/ta.go

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

111 Commits
LICENSE
LICENSE
 
 
README.md
README.md
 
 
all_test.go
all_test.go
 
 
go.mod
go.mod
 
 
go.sum
go.sum
 
 
ta.go
ta.go
 
 

Repository files navigation

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: Bitvested/ta.js#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

About

No description, website, or topics provided.

Resources

Readme

License

MIT license
Activity
Custom properties

Stars

3 stars

Watchers

1 watching

Forks

3 forks
Report repository

Releases 13

v 0.0.13 Latest
Jan 15, 2023
+ 12 releases

Packages

No packages published

Languages