PDL::Finance::TA - Technical Analysis Library (http://ta-lib.org) bindings for PDL
use PDL; use PDL::Finance::TA; # first load market data you want to analyze my $open = ... ; # 1D piddle my $high = ... ; # 1D piddle my $low = ... ; # 1D piddle my $close = ... ; # 1D piddle my $volume = ... ; # 1D piddle my $period = 20; my $moving_average = ta_sma($close, $period); my $money_flow_index = ta_mfi($high, $low, $close, $volume, $period); # both $moving_average and $money_flow_index are 1D piddles
TA-Lib library - http://ta-lib.org - is a multi-platform tool for market analysis. TA-Lib is widely used by trading software developers requiring to perform technical analysis of financial market data.
This module provides an PDL interface for TA-Lib library. It combines rich TA-Lib functionality with excelent PDL performance of handling huge data.
If you are not a PDL user you might be interested in Finance::TA module which provides approximately the same set of functions working with common perl data structures (which is fine if you are not about to process large data sets and if you generally do not worry about performace).
ta_bbands (Bollinger Bands), ta_dema (Double Exponential Moving Average), ta_ema (Exponential Moving Average), ta_ht_trendline (Hilbert Transform - Instantaneous Trendline), ta_kama (Kaufman Adaptive Moving Average), ta_ma (Moving average), ta_mama (MESA Adaptive Moving Average), ta_mavp (Moving average with variable period), ta_midpoint (MidPoint over period), ta_midprice (Midpoint Price over period), ta_sar (Parabolic SAR), ta_sarext (Parabolic SAR - Extended), ta_sma (Simple Moving Average), ta_t3 (Triple Exponential Moving Average (T3)), ta_tema (Triple Exponential Moving Average), ta_trima (Triangular Moving Average), ta_wma (Weighted Moving Average)
ta_atr (Average True Range), ta_natr (Normalized Average True Range), ta_trange (True Range)
ta_adx (Average Directional Movement Index), ta_adxr (Average Directional Movement Index Rating), ta_apo (Absolute Price Oscillator), ta_aroon (Aroon), ta_aroonosc (Aroon Oscillator), ta_bop (Balance Of Power), ta_cci (Commodity Channel Index), ta_cmo (Chande Momentum Oscillator), ta_dx (Directional Movement Index), ta_macd (Moving Average Convergence/Divergence), ta_macdext (MACD with controllable MA type), ta_macdfix (Moving Average Convergence/Divergence Fix 12/26), ta_mfi (Money Flow Index), ta_minus_di (Minus Directional Indicator), ta_minus_dm (Minus Directional Movement), ta_mom (Momentum), ta_plus_di (Plus Directional Indicator), ta_plus_dm (Plus Directional Movement), ta_ppo (Percentage Price Oscillator), ta_roc (Rate of change : ((price/prevPrice)-1)*100), ta_rocp (Rate of change Percentage: (price-prevPrice)/prevPrice), ta_rocr (Rate of change ratio: (price/prevPrice)), ta_rocr100 (Rate of change ratio 100 scale: (price/prevPrice)*100), ta_rsi (Relative Strength Index), ta_stoch (Stochastic), ta_stochf (Stochastic Fast), ta_stochrsi (Stochastic Relative Strength Index), ta_trix (1-day Rate-Of-Change (ROC) of a Triple Smooth EMA), ta_ultosc (Ultimate Oscillator), ta_willr (Williams' %R)
ta_ht_dcperiod (Hilbert Transform - Dominant Cycle Period), ta_ht_dcphase (Hilbert Transform - Dominant Cycle Phase), ta_ht_phasor (Hilbert Transform - Phasor Components), ta_ht_sine (Hilbert Transform - SineWave), ta_ht_trendmode (Hilbert Transform - Trend vs Cycle Mode)
ta_ad (Chaikin A/D Line), ta_adosc (Chaikin A/D Oscillator), ta_obv (On Balance Volume)
ta_cdl2crows (Two Crows), ta_cdl3blackcrows (Three Black Crows), ta_cdl3inside (Three Inside Up/Down), ta_cdl3linestrike (Three-Line Strike ), ta_cdl3outside (Three Outside Up/Down), ta_cdl3starsinsouth (Three Stars In The South), ta_cdl3whitesoldiers (Three Advancing White Soldiers), ta_cdlabandonedbaby (Abandoned Baby), ta_cdladvanceblock (Advance Block), ta_cdlbelthold (Belt-hold), ta_cdlbreakaway (Breakaway), ta_cdlclosingmarubozu (Closing Marubozu), ta_cdlconcealbabyswall (Concealing Baby Swallow), ta_cdlcounterattack (Counterattack), ta_cdldarkcloudcover (Dark Cloud Cover), ta_cdldoji (Doji), ta_cdldojistar (Doji Star), ta_cdldragonflydoji (Dragonfly Doji), ta_cdlengulfing (Engulfing Pattern), ta_cdleveningdojistar (Evening Doji Star), ta_cdleveningstar (Evening Star), ta_cdlgapsidesidewhite (Up/Down-gap side-by-side white lines), ta_cdlgravestonedoji (Gravestone Doji), ta_cdlhammer (Hammer), ta_cdlhangingman (Hanging Man), ta_cdlharami (Harami Pattern), ta_cdlharamicross (Harami Cross Pattern), ta_cdlhighwave (High-Wave Candle), ta_cdlhikkake (Hikkake Pattern), ta_cdlhikkakemod (Modified Hikkake Pattern), ta_cdlhomingpigeon (Homing Pigeon), ta_cdlidentical3crows (Identical Three Crows), ta_cdlinneck (In-Neck Pattern), ta_cdlinvertedhammer (Inverted Hammer), ta_cdlkicking (Kicking), ta_cdlkickingbylength (Kicking - bull/bear determined by the longer marubozu), ta_cdlladderbottom (Ladder Bottom), ta_cdllongleggeddoji (Long Legged Doji), ta_cdllongline (Long Line Candle), ta_cdlmarubozu (Marubozu), ta_cdlmatchinglow (Matching Low), ta_cdlmathold (Mat Hold), ta_cdlmorningdojistar (Morning Doji Star), ta_cdlmorningstar (Morning Star), ta_cdlonneck (On-Neck Pattern), ta_cdlpiercing (Piercing Pattern), ta_cdlrickshawman (Rickshaw Man), ta_cdlrisefall3methods (Rising/Falling Three Methods), ta_cdlseparatinglines (Separating Lines), ta_cdlshootingstar (Shooting Star), ta_cdlshortline (Short Line Candle), ta_cdlspinningtop (Spinning Top), ta_cdlstalledpattern (Stalled Pattern), ta_cdlsticksandwich (Stick Sandwich), ta_cdltakuri (Takuri (Dragonfly Doji with very long lower shadow)), ta_cdltasukigap (Tasuki Gap), ta_cdlthrusting (Thrusting Pattern), ta_cdltristar (Tristar Pattern), ta_cdlunique3river (Unique 3 River), ta_cdlupsidegap2crows (Upside Gap Two Crows), ta_cdlxsidegap3methods (Upside/Downside Gap Three Methods)
ta_beta (Beta), ta_correl (Pearson's Correlation Coefficient (r)), ta_linearreg (Linear Regression), ta_linearreg_angle (Linear Regression Angle), ta_linearreg_intercept (Linear Regression Intercept), ta_linearreg_slope (Linear Regression Slope), ta_stddev (Standard Deviation), ta_tsf (Time Series Forecast), ta_var (Variance)
ta_avgprice (Average Price), ta_medprice (Median Price), ta_typprice (Typical Price), ta_wclprice (Weighted Close Price)
Most of the available functions may return BAD values, for example:
use PDL; use PDL::Finance::TA; my $PD = pdl([0, 1, 2, 3, 4, 5]); my $MA = ta_ma($PD, 3, 1); print $MA; # prints: [BAD BAD 1 2 3 4]
All available functions handles BAD values in input piddles (BAD values at the beginning are skipped), for example:
use PDL; use PDL::Finance::TA; my $PD = pdl([0, 1, 2, 3, 4, 5]); my $MA1 = ta_ma($PD, 3, 1); say $MA1; # prints: [BAD BAD 1 2 3 4] my $MA2 = ta_ma($MA1, 3, 1); say $MA2; # prints: [BAD BAD BAD BAD 2 3]
Signature: (double inpdl(n); int InTimePeriod(); double InNbDevUp(); double InNbDevDn(); int InMAType(); double [o]outpdlUpperBand(n); double [o]outpdlMiddleBand(n); double [o]outpdlLowerBand(n))
Bollinger Bands
($outpdlUpperBand, $outpdlMiddleBand, $outpdlLowerBand) = ta_bbands($inpdl, $InTimePeriod, $InNbDevUp, $InNbDevDn, $InMAType); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 5 # valid range: min=2 max=100000 # $InNbDevUp [Deviation multiplier for upper band] - real number # default: 2 # valid range: min=-3e+037 max=3e+037 # $InNbDevDn [Deviation multiplier for lower band] - real number # default: 2 # valid range: min=-3e+037 max=3e+037 # $InMAType [Type of Moving Average] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outpdlUpperBand - 1D piddle # returns: $outpdlMiddleBand - 1D piddle # returns: $outpdlLowerBand - 1D piddle
ta_bbands processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InTimePeriod(); double [o]outpdl(n))
Double Exponential Moving Average
$outpdl = ta_dema($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_dema processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Exponential Moving Average
$outpdl = ta_ema($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_ema processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double [o]outpdl(n))
Hilbert Transform - Instantaneous Trendline
$outpdl = ta_ht_trendline($inpdl); # $inpdl - 1D piddle with input data # returns: $outpdl - 1D piddle
ta_ht_trendline processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Kaufman Adaptive Moving Average
$outpdl = ta_kama($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_kama processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InTimePeriod(); int InMAType(); double [o]outpdl(n))
Moving average
$outpdl = ta_ma($inpdl, $InTimePeriod, $InMAType); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=1 max=100000 # $InMAType [Type of Moving Average] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outpdl - 1D piddle
ta_ma processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double InFastLimit(); double InSlowLimit(); double [o]outMAMA(n); double [o]outFAMA(n))
MESA Adaptive Moving Average
($outMAMA, $outFAMA) = ta_mama($inpdl, $InFastLimit, $InSlowLimit); # $inpdl - 1D piddle with input data # $InFastLimit [Upper limit use in the adaptive algorithm] - real number # default: 0.5 # valid range: min=0.01 max=0.99 # $InSlowLimit [Lower limit use in the adaptive algorithm] - real number # default: 0.05 # valid range: min=0.01 max=0.99 # returns: $outMAMA - 1D piddle # returns: $outFAMA - 1D piddle
ta_mama processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double inPeriods(n); int InMinPeriod(); int InMaxPeriod(); int InMAType(); double [o]outpdl(n))
Moving average with variable period
$outpdl = ta_mavp($inpdl, $inPeriods, $InMinPeriod, $InMaxPeriod, $InMAType); # $inpdl - 1D piddle with input data # $inPeriods - 1D piddle # $InMinPeriod [Value less than minimum will be changed to Minimum period] - integer # default: 2 # valid range: min=2 max=100000 # $InMaxPeriod [Value higher than maximum will be changed to Maximum period] - integer # default: 30 # valid range: min=2 max=100000 # $InMAType [Type of Moving Average] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outpdl - 1D piddle
ta_mavp processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
MidPoint over period
$outpdl = ta_midpoint($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_midpoint processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); int InTimePeriod(); double [o]outpdl(n))
Midpoint Price over period
$outpdl = ta_midprice($high, $low, $InTimePeriod); # $high, $low - 1D piddles, both have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_midprice processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double InAcceleration(); double InMaximum(); double [o]outpdl(n))
Parabolic SAR
$outpdl = ta_sar($high, $low, $InAcceleration, $InMaximum); # $high, $low - 1D piddles, both have to be the same size # $InAcceleration [Acceleration Factor used up to the Maximum value] - real number # default: 0.02 # valid range: min=0 max=3e+037 # $InMaximum [Acceleration Factor Maximum value] - real number # default: 0.2 # valid range: min=0 max=3e+037 # returns: $outpdl - 1D piddle
ta_sar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double InStartValue(); double InOffsetOnReverse(); double InAccelerationInitLong(); double InAccelerationLong(); double InAccelerationMaxLong(); double InAccelerationInitShort(); double InAccelerationShort(); double InAccelerationMaxShort(); double [o]outpdl(n))
Parabolic SAR - Extended
$outpdl = ta_sarext($high, $low, $InStartValue, $InOffsetOnReverse, $InAccelerationInitLong, $InAccelerationLong, $InAccelerationMaxLong, $InAccelerationInitShort, $InAccelerationShort, $InAccelerationMaxShort); # $high, $low - 1D piddles, both have to be the same size # $InStartValue [Start value and direction. 0 for Auto, >0 for Long, <0 for Short] - real number # default: 0 # valid range: min=-3e+037 max=3e+037 # $InOffsetOnReverse [Percent offset added/removed to initial stop on short/long reversal] - real number # default: 0 # valid range: min=0 max=3e+037 # $InAccelerationInitLong [Acceleration Factor initial value for the Long direction] - real number # default: 0.02 # valid range: min=0 max=3e+037 # $InAccelerationLong [Acceleration Factor for the Long direction] - real number # default: 0.02 # valid range: min=0 max=3e+037 # $InAccelerationMaxLong [Acceleration Factor maximum value for the Long direction] - real number # default: 0.2 # valid range: min=0 max=3e+037 # $InAccelerationInitShort [Acceleration Factor initial value for the Short direction] - real number # default: 0.02 # valid range: min=0 max=3e+037 # $InAccelerationShort [Acceleration Factor for the Short direction] - real number # default: 0.02 # valid range: min=0 max=3e+037 # $InAccelerationMaxShort [Acceleration Factor maximum value for the Short direction] - real number # default: 0.2 # valid range: min=0 max=3e+037 # returns: $outpdl - 1D piddle
ta_sarext processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Simple Moving Average
$outpdl = ta_sma($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_sma processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InTimePeriod(); double InVFactor(); double [o]outpdl(n))
Triple Exponential Moving Average (T3)
$outpdl = ta_t3($inpdl, $InTimePeriod, $InVFactor); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 5 # valid range: min=2 max=100000 # $InVFactor [Volume Factor] - real number # default: 0.7 # valid range: min=0 max=1 # returns: $outpdl - 1D piddle
ta_t3 processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Triple Exponential Moving Average
$outpdl = ta_tema($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_tema processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Triangular Moving Average
$outpdl = ta_trima($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_trima processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Weighted Moving Average
$outpdl = ta_wma($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_wma processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); int InTimePeriod(); double [o]outpdl(n))
Average True Range
$outpdl = ta_atr($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_atr processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Normalized Average True Range
$outpdl = ta_natr($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_natr processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); double [o]outpdl(n))
True Range
$outpdl = ta_trange($high, $low, $close); # $high, $low, $close - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_trange processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Average Directional Movement Index
$outpdl = ta_adx($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_adx processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Average Directional Movement Index Rating
$outpdl = ta_adxr($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_adxr processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InFastPeriod(); int InSlowPeriod(); int InMAType(); double [o]outpdl(n))
Absolute Price Oscillator
$outpdl = ta_apo($inpdl, $InFastPeriod, $InSlowPeriod, $InMAType); # $inpdl - 1D piddle with input data # $InFastPeriod [Number of period for the fast MA] - integer # default: 12 # valid range: min=2 max=100000 # $InSlowPeriod [Number of period for the slow MA] - integer # default: 26 # valid range: min=2 max=100000 # $InMAType [Type of Moving Average] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outpdl - 1D piddle
ta_apo processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); int InTimePeriod(); double [o]outAroonDown(n); double [o]outAroonUp(n))
Aroon
($outAroonDown, $outAroonUp) = ta_aroon($high, $low, $InTimePeriod); # $high, $low - 1D piddles, both have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outAroonDown - 1D piddle # returns: $outAroonUp - 1D piddle
ta_aroon processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Aroon Oscillator
$outpdl = ta_aroonosc($high, $low, $InTimePeriod); # $high, $low - 1D piddles, both have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_aroonosc processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double open(n); double high(n); double low(n); double close(n); double [o]outpdl(n))
Balance Of Power
$outpdl = ta_bop($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_bop processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Commodity Channel Index
$outpdl = ta_cci($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_cci processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Chande Momentum Oscillator
$outpdl = ta_cmo($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_cmo processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Directional Movement Index
$outpdl = ta_dx($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_dx processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InFastPeriod(); int InSlowPeriod(); int InSignalPeriod(); double [o]outMACD(n); double [o]outMACDSignal(n); double [o]outMACDHist(n))
Moving Average Convergence/Divergence
($outMACD, $outMACDSignal, $outMACDHist) = ta_macd($inpdl, $InFastPeriod, $InSlowPeriod, $InSignalPeriod); # $inpdl - 1D piddle with input data # $InFastPeriod [Number of period for the fast MA] - integer # default: 12 # valid range: min=2 max=100000 # $InSlowPeriod [Number of period for the slow MA] - integer # default: 26 # valid range: min=2 max=100000 # $InSignalPeriod [Smoothing for the signal line (nb of period)] - integer # default: 9 # valid range: min=1 max=100000 # returns: $outMACD - 1D piddle # returns: $outMACDSignal - 1D piddle # returns: $outMACDHist - 1D piddle
ta_macd processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InFastPeriod(); int InFastMAType(); int InSlowPeriod(); int InSlowMAType(); int InSignalPeriod(); int InSignalMAType(); double [o]outMACD(n); double [o]outMACDSignal(n); double [o]outMACDHist(n))
MACD with controllable MA type
($outMACD, $outMACDSignal, $outMACDHist) = ta_macdext($inpdl, $InFastPeriod, $InFastMAType, $InSlowPeriod, $InSlowMAType, $InSignalPeriod, $InSignalMAType); # $inpdl - 1D piddle with input data # $InFastPeriod [Number of period for the fast MA] - integer # default: 12 # valid range: min=2 max=100000 # $InFastMAType [Type of Moving Average for fast MA] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # $InSlowPeriod [Number of period for the slow MA] - integer # default: 26 # valid range: min=2 max=100000 # $InSlowMAType [Type of Moving Average for slow MA] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # $InSignalPeriod [Smoothing for the signal line (nb of period)] - integer # default: 9 # valid range: min=1 max=100000 # $InSignalMAType [Type of Moving Average for signal line] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outMACD - 1D piddle # returns: $outMACDSignal - 1D piddle # returns: $outMACDHist - 1D piddle
ta_macdext processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InSignalPeriod(); double [o]outMACD(n); double [o]outMACDSignal(n); double [o]outMACDHist(n))
Moving Average Convergence/Divergence Fix 12/26
($outMACD, $outMACDSignal, $outMACDHist) = ta_macdfix($inpdl, $InSignalPeriod); # $inpdl - 1D piddle with input data # $InSignalPeriod [Smoothing for the signal line (nb of period)] - integer # default: 9 # valid range: min=1 max=100000 # returns: $outMACD - 1D piddle # returns: $outMACDSignal - 1D piddle # returns: $outMACDHist - 1D piddle
ta_macdfix processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); double volume(n); int InTimePeriod(); double [o]outpdl(n))
Money Flow Index
$outpdl = ta_mfi($high, $low, $close, $volume, $InTimePeriod); # $high, $low, $close, $volume - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_mfi processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Minus Directional Indicator
$outpdl = ta_minus_di($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_minus_di processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Minus Directional Movement
$outpdl = ta_minus_dm($high, $low, $InTimePeriod); # $high, $low - 1D piddles, both have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_minus_dm processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Momentum
$outpdl = ta_mom($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 10 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_mom processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Plus Directional Indicator
$outpdl = ta_plus_di($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_plus_di processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Plus Directional Movement
$outpdl = ta_plus_dm($high, $low, $InTimePeriod); # $high, $low - 1D piddles, both have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_plus_dm processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Percentage Price Oscillator
$outpdl = ta_ppo($inpdl, $InFastPeriod, $InSlowPeriod, $InMAType); # $inpdl - 1D piddle with input data # $InFastPeriod [Number of period for the fast MA] - integer # default: 12 # valid range: min=2 max=100000 # $InSlowPeriod [Number of period for the slow MA] - integer # default: 26 # valid range: min=2 max=100000 # $InMAType [Type of Moving Average] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outpdl - 1D piddle
ta_ppo processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rate of change : ((price/prevPrice-1)*100)
$outpdl = ta_roc($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 10 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_roc processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rate of change Percentage: (price-prevPrice/prevPrice)
$outpdl = ta_rocp($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 10 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_rocp processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rate of change ratio: (price/prevPrice)
$outpdl = ta_rocr($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 10 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_rocr processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rate of change ratio 100 scale: (price/prevPrice*100)
$outpdl = ta_rocr100($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 10 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_rocr100 processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Relative Strength Index
$outpdl = ta_rsi($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_rsi processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); int InFastK_Period(); int InSlowK_Period(); int InSlowK_MAType(); int InSlowD_Period(); int InSlowD_MAType(); double [o]outSlowK(n); double [o]outSlowD(n))
Stochastic
($outSlowK, $outSlowD) = ta_stoch($high, $low, $close, $InFastK_Period, $InSlowK_Period, $InSlowK_MAType, $InSlowD_Period, $InSlowD_MAType); # $high, $low, $close - 1D piddles, all have to be the same size # $InFastK_Period [Time period for building the Fast-K line] - integer # default: 5 # valid range: min=1 max=100000 # $InSlowK_Period [Smoothing for making the Slow-K line. Usually set to 3] - integer # default: 3 # valid range: min=1 max=100000 # $InSlowK_MAType [Type of Moving Average for Slow-K] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # $InSlowD_Period [Smoothing for making the Slow-D line] - integer # default: 3 # valid range: min=1 max=100000 # $InSlowD_MAType [Type of Moving Average for Slow-D] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outSlowK - 1D piddle # returns: $outSlowD - 1D piddle
ta_stoch processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); int InFastK_Period(); int InFastD_Period(); int InFastD_MAType(); double [o]outFastK(n); double [o]outFastD(n))
Stochastic Fast
($outFastK, $outFastD) = ta_stochf($high, $low, $close, $InFastK_Period, $InFastD_Period, $InFastD_MAType); # $high, $low, $close - 1D piddles, all have to be the same size # $InFastK_Period [Time period for building the Fast-K line] - integer # default: 5 # valid range: min=1 max=100000 # $InFastD_Period [Smoothing for making the Fast-D line. Usually set to 3] - integer # default: 3 # valid range: min=1 max=100000 # $InFastD_MAType [Type of Moving Average for Fast-D] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outFastK - 1D piddle # returns: $outFastD - 1D piddle
ta_stochf processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InTimePeriod(); int InFastK_Period(); int InFastD_Period(); int InFastD_MAType(); double [o]outFastK(n); double [o]outFastD(n))
Stochastic Relative Strength Index
($outFastK, $outFastD) = ta_stochrsi($inpdl, $InTimePeriod, $InFastK_Period, $InFastD_Period, $InFastD_MAType); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # $InFastK_Period [Time period for building the Fast-K line] - integer # default: 5 # valid range: min=1 max=100000 # $InFastD_Period [Smoothing for making the Fast-D line. Usually set to 3] - integer # default: 3 # valid range: min=1 max=100000 # $InFastD_MAType [Type of Moving Average for Fast-D] - integer # default: 0 # valid values: 0=SMA 1=EMA 2=WMA 3=DEMA 4=TEMA 5=TRIMA 6=KAMA 7=MAMA 8=T3 # returns: $outFastK - 1D piddle # returns: $outFastD - 1D piddle
ta_stochrsi processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
1-day Rate-Of-Change (ROC of a Triple Smooth EMA)
$outpdl = ta_trix($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_trix processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); int InTimePeriod1(); int InTimePeriod2(); int InTimePeriod3(); double [o]outpdl(n))
Ultimate Oscillator
$outpdl = ta_ultosc($high, $low, $close, $InTimePeriod1, $InTimePeriod2, $InTimePeriod3); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod1 [Number of bars for 1st period.] - integer # default: 7 # valid range: min=1 max=100000 # $InTimePeriod2 [Number of bars fro 2nd period] - integer # default: 14 # valid range: min=1 max=100000 # $InTimePeriod3 [Number of bars for 3rd period] - integer # default: 28 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_ultosc processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Williams' %R
$outpdl = ta_willr($high, $low, $close, $InTimePeriod); # $high, $low, $close - 1D piddles, all have to be the same size # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_willr processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Hilbert Transform - Dominant Cycle Period
$outpdl = ta_ht_dcperiod($inpdl); # $inpdl - 1D piddle with input data # returns: $outpdl - 1D piddle
ta_ht_dcperiod processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Hilbert Transform - Dominant Cycle Phase
$outpdl = ta_ht_dcphase($inpdl); # $inpdl - 1D piddle with input data # returns: $outpdl - 1D piddle
ta_ht_dcphase processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double [o]outInPhase(n); double [o]outQuadrature(n))
Hilbert Transform - Phasor Components
($outInPhase, $outQuadrature) = ta_ht_phasor($inpdl); # $inpdl - 1D piddle with input data # returns: $outInPhase - 1D piddle # returns: $outQuadrature - 1D piddle
ta_ht_phasor processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double [o]outSine(n); double [o]outLeadSine(n))
Hilbert Transform - SineWave
($outSine, $outLeadSine) = ta_ht_sine($inpdl); # $inpdl - 1D piddle with input data # returns: $outSine - 1D piddle # returns: $outLeadSine - 1D piddle
ta_ht_sine processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int [o]outInteger(n))
Hilbert Transform - Trend vs Cycle Mode
$outInteger = ta_ht_trendmode($inpdl); # $inpdl - 1D piddle with input data # returns: $outInteger - 1D piddle
ta_ht_trendmode processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); double volume(n); double [o]outpdl(n))
Chaikin A/D Line
$outpdl = ta_ad($high, $low, $close, $volume); # $high, $low, $close, $volume - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_ad processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double close(n); double volume(n); int InFastPeriod(); int InSlowPeriod(); double [o]outpdl(n))
Chaikin A/D Oscillator
$outpdl = ta_adosc($high, $low, $close, $volume, $InFastPeriod, $InSlowPeriod); # $high, $low, $close, $volume - 1D piddles, all have to be the same size # $InFastPeriod [Number of period for the fast MA] - integer # default: 3 # valid range: min=2 max=100000 # $InSlowPeriod [Number of period for the slow MA] - integer # default: 10 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_adosc processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); double volume(n); double [o]outpdl(n))
On Balance Volume
$outpdl = ta_obv($inpdl, $volume); # $inpdl - 1D piddle with input data # $volume - 1D piddle # returns: $outpdl - 1D piddle
ta_obv processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double open(n); double high(n); double low(n); double close(n); int [o]outInteger(n))
Two Crows
$outInteger = ta_cdl2crows($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl2crows processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three Black Crows
$outInteger = ta_cdl3blackcrows($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3blackcrows processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three Inside Up/Down
$outInteger = ta_cdl3inside($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3inside processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three-Line Strike
$outInteger = ta_cdl3linestrike($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3linestrike processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three Outside Up/Down
$outInteger = ta_cdl3outside($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3outside processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three Stars In The South
$outInteger = ta_cdl3starsinsouth($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3starsinsouth processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Three Advancing White Soldiers
$outInteger = ta_cdl3whitesoldiers($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdl3whitesoldiers processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double open(n); double high(n); double low(n); double close(n); double InPenetration(); int [o]outInteger(n))
Abandoned Baby
$outInteger = ta_cdlabandonedbaby($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.3 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdlabandonedbaby processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Advance Block
$outInteger = ta_cdladvanceblock($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdladvanceblock processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Belt-hold
$outInteger = ta_cdlbelthold($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlbelthold processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Breakaway
$outInteger = ta_cdlbreakaway($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlbreakaway processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Closing Marubozu
$outInteger = ta_cdlclosingmarubozu($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlclosingmarubozu processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Concealing Baby Swallow
$outInteger = ta_cdlconcealbabyswall($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlconcealbabyswall processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Counterattack
$outInteger = ta_cdlcounterattack($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlcounterattack processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Dark Cloud Cover
$outInteger = ta_cdldarkcloudcover($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.5 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdldarkcloudcover processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Doji
$outInteger = ta_cdldoji($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdldoji processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Doji Star
$outInteger = ta_cdldojistar($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdldojistar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Dragonfly Doji
$outInteger = ta_cdldragonflydoji($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdldragonflydoji processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Engulfing Pattern
$outInteger = ta_cdlengulfing($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlengulfing processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Evening Doji Star
$outInteger = ta_cdleveningdojistar($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.3 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdleveningdojistar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Evening Star
$outInteger = ta_cdleveningstar($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.3 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdleveningstar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Up/Down-gap side-by-side white lines
$outInteger = ta_cdlgapsidesidewhite($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlgapsidesidewhite processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Gravestone Doji
$outInteger = ta_cdlgravestonedoji($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlgravestonedoji processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Hammer
$outInteger = ta_cdlhammer($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhammer processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Hanging Man
$outInteger = ta_cdlhangingman($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhangingman processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Harami Pattern
$outInteger = ta_cdlharami($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlharami processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Harami Cross Pattern
$outInteger = ta_cdlharamicross($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlharamicross processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
High-Wave Candle
$outInteger = ta_cdlhighwave($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhighwave processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Hikkake Pattern
$outInteger = ta_cdlhikkake($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhikkake processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Modified Hikkake Pattern
$outInteger = ta_cdlhikkakemod($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhikkakemod processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Homing Pigeon
$outInteger = ta_cdlhomingpigeon($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlhomingpigeon processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Identical Three Crows
$outInteger = ta_cdlidentical3crows($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlidentical3crows processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
In-Neck Pattern
$outInteger = ta_cdlinneck($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlinneck processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Inverted Hammer
$outInteger = ta_cdlinvertedhammer($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlinvertedhammer processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Kicking
$outInteger = ta_cdlkicking($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlkicking processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Kicking - bull/bear determined by the longer marubozu
$outInteger = ta_cdlkickingbylength($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlkickingbylength processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Ladder Bottom
$outInteger = ta_cdlladderbottom($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlladderbottom processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Long Legged Doji
$outInteger = ta_cdllongleggeddoji($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdllongleggeddoji processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Long Line Candle
$outInteger = ta_cdllongline($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdllongline processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Marubozu
$outInteger = ta_cdlmarubozu($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlmarubozu processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Matching Low
$outInteger = ta_cdlmatchinglow($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlmatchinglow processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Mat Hold
$outInteger = ta_cdlmathold($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.5 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdlmathold processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Morning Doji Star
$outInteger = ta_cdlmorningdojistar($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.3 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdlmorningdojistar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Morning Star
$outInteger = ta_cdlmorningstar($open, $high, $low, $close, $InPenetration); # $open, $high, $low, $close - 1D piddles, all have to be the same size # $InPenetration [Percentage of penetration of a candle within another candle] - real number # default: 0.3 # valid range: min=0 max=3e+037 # returns: $outInteger - 1D piddle
ta_cdlmorningstar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
On-Neck Pattern
$outInteger = ta_cdlonneck($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlonneck processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Piercing Pattern
$outInteger = ta_cdlpiercing($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlpiercing processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rickshaw Man
$outInteger = ta_cdlrickshawman($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlrickshawman processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Rising/Falling Three Methods
$outInteger = ta_cdlrisefall3methods($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlrisefall3methods processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Separating Lines
$outInteger = ta_cdlseparatinglines($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlseparatinglines processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Shooting Star
$outInteger = ta_cdlshootingstar($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlshootingstar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Short Line Candle
$outInteger = ta_cdlshortline($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlshortline processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Spinning Top
$outInteger = ta_cdlspinningtop($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlspinningtop processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Stalled Pattern
$outInteger = ta_cdlstalledpattern($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlstalledpattern processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Stick Sandwich
$outInteger = ta_cdlsticksandwich($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlsticksandwich processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Takuri (Dragonfly Doji with very long lower shadow)
$outInteger = ta_cdltakuri($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdltakuri processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Tasuki Gap
$outInteger = ta_cdltasukigap($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdltasukigap processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Thrusting Pattern
$outInteger = ta_cdlthrusting($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlthrusting processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Tristar Pattern
$outInteger = ta_cdltristar($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdltristar processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Unique 3 River
$outInteger = ta_cdlunique3river($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlunique3river processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Upside Gap Two Crows
$outInteger = ta_cdlupsidegap2crows($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlupsidegap2crows processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Upside/Downside Gap Three Methods
$outInteger = ta_cdlxsidegap3methods($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outInteger - 1D piddle
ta_cdlxsidegap3methods processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl0(n); double inpdl1(n); int InTimePeriod(); double [o]outpdl(n))
Beta
$outpdl = ta_beta($inpdl0, $inpdl1, $InTimePeriod); # $inpdl0 - 1D piddle # $inpdl1 - 1D piddle # $InTimePeriod [Number of period] - integer # default: 5 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_beta processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Pearson's Correlation Coefficient (r)
$outpdl = ta_correl($inpdl0, $inpdl1, $InTimePeriod); # $inpdl0 - 1D piddle # $inpdl1 - 1D piddle # $InTimePeriod [Number of period] - integer # default: 30 # valid range: min=1 max=100000 # returns: $outpdl - 1D piddle
ta_correl processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Linear Regression
$outpdl = ta_linearreg($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_linearreg processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Linear Regression Angle
$outpdl = ta_linearreg_angle($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_linearreg_angle processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Linear Regression Intercept
$outpdl = ta_linearreg_intercept($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_linearreg_intercept processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Linear Regression Slope
$outpdl = ta_linearreg_slope($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_linearreg_slope processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double inpdl(n); int InTimePeriod(); double InNbDev(); double [o]outpdl(n))
Standard Deviation
$outpdl = ta_stddev($inpdl, $InTimePeriod, $InNbDev); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 5 # valid range: min=2 max=100000 # $InNbDev [Nb of deviations] - real number # default: 1 # valid range: min=-3e+037 max=3e+037 # returns: $outpdl - 1D piddle
ta_stddev processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Time Series Forecast
$outpdl = ta_tsf($inpdl, $InTimePeriod); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 14 # valid range: min=2 max=100000 # returns: $outpdl - 1D piddle
ta_tsf processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Variance
$outpdl = ta_var($inpdl, $InTimePeriod, $InNbDev); # $inpdl - 1D piddle with input data # $InTimePeriod [Number of period] - integer # default: 5 # valid range: min=1 max=100000 # $InNbDev [Nb of deviations] - real number # default: 1 # valid range: min=-3e+037 max=3e+037 # returns: $outpdl - 1D piddle
ta_var processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Average Price
$outpdl = ta_avgprice($open, $high, $low, $close); # $open, $high, $low, $close - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_avgprice processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Signature: (double high(n); double low(n); double [o]outpdl(n))
Median Price
$outpdl = ta_medprice($high, $low); # $high, $low - 1D piddles, both have to be the same size # returns: $outpdl - 1D piddle
ta_medprice processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Typical Price
$outpdl = ta_typprice($high, $low, $close); # $high, $low, $close - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_typprice processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
Weighted Close Price
$outpdl = ta_wclprice($high, $low, $close); # $high, $low, $close - 1D piddles, all have to be the same size # returns: $outpdl - 1D piddle
ta_wclprice processes bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
To install PDL::Finance::TA, copy and paste the appropriate command in to your terminal.
cpanm
cpanm PDL::Finance::TA
CPAN shell
perl -MCPAN -e shell install PDL::Finance::TA
For more information on module installation, please visit the detailed CPAN module installation guide.