Package 'talib'

Description

abandoned_baby() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

abandoned_baby(x, cols, eps = 0, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLABANDONEDBABY

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::abandoned_baby(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::abandoned_baby
 )
}

Description

absolute_price_oscillator() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

absolute_price_oscillator() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

absolute_price_oscillator(
  x,
  cols,
  fast = 12,
  slow = 26,
  ma = SMA(n = 9),
  na.bridge = FALSE,
  ...
)

Arguments

Value

An object of same class and length of x:

APO

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: aroon(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::absolute_price_oscillator(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::absolute_price_oscillator
 )
}

Description

acceleration_bands() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

acceleration_bands(x, cols, n = 20, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

UpperBand

double

MiddleBand

double

LowerBand

double

Author(s)

Serkan Korkmaz

See Also

Other Overlap Study: bollinger_bands(), double_exponential_moving_average(), exponential_moving_average(), extended_parabolic_stop_and_reverse(), kaufman_adaptive_moving_average(), mesa_adaptive_moving_average(), parabolic_stop_and_reverse(), simple_moving_average(), t3_exponential_moving_average(), trendline(), triangular_moving_average(), triple_exponential_moving_average(), weighted_moving_average()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::acceleration_bands(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::acceleration_bands
 )
}

Description

advance_block() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

advance_block(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLADVANCEBLOCK

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::advance_block(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::advance_block
 )
}

Description

aroon() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

aroon(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

AroonDown

double

AroonUp

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::aroon(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::aroon
 )
}

Description

aroon_oscillator() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

aroon_oscillator(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

AROONOSC

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::aroon_oscillator(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::aroon_oscillator
 )
}

Description

Daily OHLCV price data for Cosmos (ATOM), denominated in USDC, covering 2022-01-01 to 2022-12-31. Includes a full bear-market cycle useful for testing candlestick pattern recognition on cryptocurrency data.

Usage

ATOM

Format

A data.frame with 366 rows and 5 columns.

open

Opening price for the trading day.

high

Highest price reached during the trading day.

low

Lowest price reached during the trading day.

close

Closing price for the trading day.

volume

Total trading volume for the day.

Source

Loaded using cryptoQuotes.

Examples

## Load the dataset
data(ATOM, package = "talib")

## Scan for Doji patterns on ATOM
talib::doji(ATOM)

Description

average_directional_movement_index() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

average_directional_movement_index(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

ADX

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::average_directional_movement_index(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::average_directional_movement_index
 )
}

Description

average_directional_movement_index_rating() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

average_directional_movement_index_rating(
  x,
  cols,
  n = 14,
  na.bridge = FALSE,
  ...
)

Arguments

Value

An object of same class and length of x:

ADXR

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::average_directional_movement_index_rating(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::average_directional_movement_index_rating
 )
}

Description

average_price() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

average_price(x, cols, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

AVGPRICE

double

Author(s)

Serkan Korkmaz

See Also

Other Price Transform: median_price(), midpoint_price(), typical_price(), weighted_close_price()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::average_price(BTC)

## display the results
utils::tail(output)

Description

average_true_range() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

average_true_range(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

ATR

double

Author(s)

Serkan Korkmaz

See Also

Other Volatility Indicator: normalized_average_true_range(), true_range()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::average_true_range(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::average_true_range
 )
}

Description

balance_of_power() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

balance_of_power(x, cols, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

BOP

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), chande_momentum_oscillator(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::balance_of_power(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::balance_of_power
 )
}

Description

belt_hold() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

belt_hold(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLBELTHOLD

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::belt_hold(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::belt_hold
 )
}

Description

bollinger_bands() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

bollinger_bands() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

bollinger_bands(
  x,
  cols,
  ma = SMA(n = 5),
  sd = 2,
  sd_down,
  sd_up,
  na.bridge = FALSE,
  ...
)

Arguments

Value

An object of same class and length of x:

UpperBand

double

MiddleBand

double

LowerBand

double

Author(s)

Serkan Korkmaz

See Also

Other Overlap Study: acceleration_bands(), double_exponential_moving_average(), exponential_moving_average(), extended_parabolic_stop_and_reverse(), kaufman_adaptive_moving_average(), mesa_adaptive_moving_average(), parabolic_stop_and_reverse(), simple_moving_average(), t3_exponential_moving_average(), trendline(), triangular_moving_average(), triple_exponential_moving_average(), weighted_moving_average()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::bollinger_bands(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::bollinger_bands
 )
}

Description

break_away() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

break_away(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLBREAKAWAY

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::break_away(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::break_away
 )
}

Description

Daily OHLCV price data for Bitcoin (BTC), denominated in USDC, covering 2024-01-01 to 2024-12-31. Useful for testing technical analysis indicators and candlestick pattern recognition on cryptocurrency data.

Usage

BTC

Format

A data.frame with 366 rows and 5 columns.

open

Opening price for the trading day.

high

Highest price reached during the trading day.

low

Lowest price reached during the trading day.

close

Closing price for the trading day.

volume

Total trading volume for the day.

Source

Loaded using cryptoQuotes.

Examples

## Load the dataset
data(BTC, package = "talib")

## Compute RSI on Bitcoin closing prices
talib::relative_strength_index(BTC)

Description

chaikin_accumulation_distribution_line() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

chaikin_accumulation_distribution_line(x, cols, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

AD

double

Author(s)

Serkan Korkmaz

See Also

Other Volume Indicator: chaikin_accumulation_distribution_oscillator(), on_balance_volume(), trading_volume()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::chaikin_accumulation_distribution_line(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::chaikin_accumulation_distribution_line
 )
}

Description

chaikin_accumulation_distribution_oscillator() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

chaikin_accumulation_distribution_oscillator(
  x,
  cols,
  fast = 3,
  slow = 10,
  na.bridge = FALSE,
  ...
)

Arguments

Value

An object of same class and length of x:

ADOSC

double

Author(s)

Serkan Korkmaz

See Also

Other Volume Indicator: chaikin_accumulation_distribution_line(), on_balance_volume(), trading_volume()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::chaikin_accumulation_distribution_oscillator(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::chaikin_accumulation_distribution_oscillator
 )
}

Description

chande_momentum_oscillator() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

chande_momentum_oscillator() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

chande_momentum_oscillator(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

CMO

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), commodity_channel_index(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::chande_momentum_oscillator(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::chande_momentum_oscillator
 )
}

Description

chart() creates interactive candlestick or OHLC bar charts from financial price data. It initializes the charting environment so that subsequent calls to indicator() can attach technical indicators as subcharts.

Calling chart() without any arguments resets the charting environment, clearing all stored chart state (main chart, subcharts, and data).

See vignette(topic = "charting", package = "talib") for a comprehensive guide on building multi-panel technical analysis charts.

Usage

chart(x, type = "candlestick", idx = NULL, title, ...)

Arguments

Details

chart() acts as the entry point for the package's charting system. It stores the OHLC data and the main price chart internally so that subsequent indicator() calls can attach panels below the price chart without requiring the data to be passed again.

The chart title is automatically inferred from the name of the object passed to x (e.g., chart(BTC) produces the title "BTC"). The title also displays the number of observations and, when available, the date range.

Two rendering backends are supported:

"plotly" (default)

Produces interactive HTML charts with hover tooltips, pan/zoom, and built-in drawing tools (lines, rectangles). Requires the plotly package.

"ggplot2"

Produces static charts suitable for reports and publications. Requires the ggplot2 package.

Options

The following options() control chart appearance and behavior:

talib.chart.backend [character]

"plotly" by default. Set to "ggplot2" for static charts.

talib.chart.slider [logical]

FALSE by default. If TRUE, a range slider is added below the x-axis for interactive zooming (plotly backend only).

talib.chart.slider.size [numeric]

0.05 by default. Controls the height of the range slider as a fraction of the total chart height.

talib.chart.legend [logical]

TRUE by default. If FALSE, legends are hidden on all panels.

talib.chart.scale [numeric]

1 by default. A scaling factor applied to all font sizes. Values greater than 1 increase font size.

talib.chart.main [numeric]

0.7 by default. The fraction of total chart height allocated to the main price panel when subcharts are present.

Colors are controlled via set_theme(). See set_theme() for available themes and color customization.

State and concurrency

The chart() + indicator() pair follows the same active-target model as base R's plot() / lines(). When chart() is called it stashes a per-pipeline state object in its caller's evaluation frame; subsequent indicator() calls retrieve the state by walking up the call stack.

The practical consequences:

• chart() and the subsequent indicator() calls must live in the same enclosing frame - the same REPL session, the same function body, the same renderPlot() / renderPlotly() block, the same local({...}) expression, the same testthat::test_that({...}) block, etc. Splitting them across unrelated helpers is not supported.

• Two unrelated function bodies (or two parallel renderPlot() callbacks in a Shiny app, or two future::future() blocks) each get their own frame, so their chart states are isolated by construction - without talib taking any dependency on Shiny, promises, or futures.

• Calling chart() with no arguments clears the state in the caller's frame, mirroring a fresh plot() call on a new device.

Value

A chart object whose class depends on the active backend:

• "plotly" backend: a plotly object (interactive HTML widget).

• "ggplot2" backend: a gg object (static plot).

When called without arguments, returns NULL invisibly.

Author(s)

Serkan Korkmaz

See Also

indicator() to attach technical indicators, set_theme() to customize chart colors.

Other Charting: chart_themes, indicator(), set_theme()

Examples

## charting OHLC data with {talib}
data(BTC, package = "talib")

## candlestick chart (default)
talib::chart(BTC)

## OHLC bar chart
talib::chart(BTC, type = "ohlc")

## chart with a custom title
talib::chart(BTC, title = "Bitcoin / USD")

## reset the charting environment
talib::chart()

Description

The charting system ships with a set of built-in color themes. Each theme controls candle colors, background, text, grid lines, and a 10-color palette (colorway) used to distinguish indicator lines.

Use set_theme() to apply or list themes.

Details

Available Themes

default

A dark theme with cyan and steel-blue tones. Light (⁠#E0FFFF⁠) bullish candles on a near-black (⁠#141414⁠) background with a cool blue (⁠#4682B4⁠) bearish candle. The colorway spans icy blues through teal and soft purple.

hawks_and_doves

A light, grayscale theme with a white background. Candles use shades of gray, making it suitable for print or presentations where color is secondary. The colorway uses muted, accessible tones.

payout

A dark teal theme on a near-black (⁠#1A1A1A⁠) background. Bullish candles are teal (⁠#008080⁠), bearish candles are dark slate (⁠#2F4F4F⁠). The colorway follows the default Plotly palette.

tp_slapped

A bright theme on a light gray (⁠#ECF0F1⁠) background. Red (⁠#E74C3C⁠) bearish and teal (⁠#1ABC9C⁠) bullish candles provide strong visual contrast. The colorway uses vivid, saturated colors.

trust_the_process

A subtle, earth-toned theme on a light gray (⁠#F5F5F5⁠) background. Both bull and bear candles use shades of gray, keeping the focus on indicator lines. The colorway uses muted natural tones.

bloomberg_terminal

A dark theme on a near-black (⁠#0E1017⁠) background with orange (⁠#FF8F40⁠) bullish and neutral-gray (⁠#BBB9B2⁠) bearish candles. Inspired by the Bloomberg Terminal interface. Colorblind-friendly (see below).

limit_up

A dark monochrome theme on a near-black (⁠#121212⁠) background. Candles use only luminance to encode direction (light-gray bullish vs dark-gray bearish). Colorblind-friendly (see below).

bid_n_ask

A light theme on an azure (⁠#F0FFFF⁠) background with steel-blue (⁠#4682B4⁠) bullish and tomato-red (⁠#FF6347⁠) bearish candles. The classic blue-vs-red trading pair. Colorblind-friendly (see below).

Colorblind-Friendly Themes

The following themes encode bull/bear direction in ways that remain distinguishable under the most common color-vision deficiencies. The colorways for bloomberg_terminal, limit_up, and bid_n_ask are derived from the Okabe & Ito (2008) qualitative palette, the de-facto standard for accessible scientific visualization.

limit_up, hawks_and_doves, trust_the_process

Encode direction with luminance only. Safe under deuteranopia, protanopia, tritanopia, and full achromatopsia.

bloomberg_terminal

Orange + neutral gray. Safe under all three CVD types thanks to Okabe-Ito-style hue separation.

default, payout

Cyan/teal + blue or dark slate. Safe under all three CVD types — the color pair sits inside the blue-yellow axis that CVD users perceive normally.

bid_n_ask

Blue + red. Safe under deuteranopia and protanopia (the most common forms, affecting ~8% of males); the pair separates more weakly under tritanopia.

tp_slapped is the only built-in that uses a teal/red pair adjacent to the red-green CVD axis; prefer the themes above when accessibility matters.

Theme Properties

Each theme sets the following color properties:

Candle colors

bearish_body, bearish_wick, bearish_border, bullish_body, bullish_wick, bullish_border

General colors

background_color, foreground_color (axes and borders), text_color

Grid and reference

gridcolor, threshold_color (horizontal reference lines such as overbought/oversold levels)

Colorway

A vector of 10 colors cycled through for indicator lines and legends

Any of these properties can be individually overridden via the ... argument to set_theme().

References

Okabe, M. & Ito, K. (2008). Color Universal Design (CUD): How to make figures and presentations that are friendly to colorblind people. https://jfly.uni-koeln.de/color/

See Also

Other Charting: chart(), indicator(), set_theme()

Examples

## list available themes
talib::set_theme()

## apply a theme by name
talib::set_theme("payout")

## apply a theme with custom overrides
talib::set_theme(
  "hawks_and_doves",
  background_color = "#FAFAFA"
)

## override individual properties
## without switching theme
talib::set_theme(
  bearish_body = "#FF4444",
  bullish_body = "#44FF44"
)

## reset to default theme
talib::set_theme("default")

Description

closing_marubozu() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

closing_marubozu(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLCLOSINGMARUBOZU

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::closing_marubozu(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::closing_marubozu
 )
}

Description

commodity_channel_index() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

commodity_channel_index(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

CCI

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), directional_movement_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::commodity_channel_index(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::commodity_channel_index
 )
}

Description

concealing_baby_swallow() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

concealing_baby_swallow(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLCONCEALBABYSWALL

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::concealing_baby_swallow(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::concealing_baby_swallow
 )
}

Description

counter_attack() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

counter_attack(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLCOUNTERATTACK

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), dark_cloud_cover(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::counter_attack(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::counter_attack
 )
}

Description

dark_cloud_cover() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

dark_cloud_cover(x, cols, eps = 0, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLDARKCLOUDCOVER

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), doji(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::dark_cloud_cover(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::dark_cloud_cover
 )
}

Description

directional_movement_index() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

directional_movement_index(x, cols, n = 14, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

DX

double

Author(s)

Serkan Korkmaz

See Also

Other Momentum Indicator: absolute_price_oscillator(), aroon(), aroon_oscillator(), average_directional_movement_index(), average_directional_movement_index_rating(), balance_of_power(), chande_momentum_oscillator(), commodity_channel_index(), extended_moving_average_convergence_divergence(), fast_stochastic(), fixed_moving_average_convergence_divergence(), intraday_movement_index(), minus_directional_indicator(), minus_directional_movement(), momentum(), money_flow_index(), moving_average_convergence_divergence(), percentage_price_oscillator(), plus_directional_indicator(), plus_directional_movement(), rate_of_change(), ratio_of_change(), relative_strength_index(), stochastic(), stochastic_relative_strength_index(), triple_exponential_average(), ultimate_oscillator(), williams_oscillator()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::directional_movement_index(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::directional_movement_index
 )
}

Description

doji() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

doji(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLDOJI

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji_star(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::doji(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::doji
 )
}

Description

doji_star() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

doji_star(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLDOJISTAR

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), dragonfly_doji(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::doji_star(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::doji_star
 )
}

Description

dominant_cycle_period() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

dominant_cycle_period() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

dominant_cycle_period(x, cols, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

HT_DCPERIOD

double

Author(s)

Serkan Korkmaz

See Also

Other Cycle Indicator: dominant_cycle_phase(), phasor_components(), sine_wave(), trend_cycle_mode()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::dominant_cycle_period(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::dominant_cycle_period
 )
}

Description

dominant_cycle_phase() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

dominant_cycle_phase() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

dominant_cycle_phase(x, cols, na.bridge = FALSE, ...)

Arguments

Value

An object of same class and length of x:

HT_DCPHASE

double

Author(s)

Serkan Korkmaz

See Also

Other Cycle Indicator: dominant_cycle_period(), phasor_components(), sine_wave(), trend_cycle_mode()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::dominant_cycle_phase(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::dominant_cycle_phase
 )
}

Description

double_exponential_moving_average() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

double_exponential_moving_average() also accepts a double vector, in which case the indicator is calculated directly without column selection. When the result has a single column it is simplified to a double vector; otherwise the full n by k matrix is returned.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

double_exponential_moving_average(x, cols, n = 30, na.bridge = FALSE, ...)

Arguments

Details

When passed without 'x', double_exponential_moving_average functions as an 'Moving Average'-specification which is used in, for example, stochastic when constructing the smoothing lines.

When called without 'x' it will return a named list which is used for the indicators that supports various Moving Average specifications.

Value

An object of same class and length of x:

DEMA

double

Author(s)

Serkan Korkmaz

See Also

Other Overlap Study: acceleration_bands(), bollinger_bands(), exponential_moving_average(), extended_parabolic_stop_and_reverse(), kaufman_adaptive_moving_average(), mesa_adaptive_moving_average(), parabolic_stop_and_reverse(), simple_moving_average(), t3_exponential_moving_average(), trendline(), triangular_moving_average(), triple_exponential_moving_average(), weighted_moving_average()

Examples

## load Bitcoin (BTC)
## series
data(BTC, package = "talib")

## calculate the indicator
## for Bitcoin (BTC)
output <- talib::double_exponential_moving_average(BTC)

## display the results
utils::tail(output)

## visualize the indicator
## with talib::chart()
##
## see ?talib::chart or ?talib::indicator
## for more details
{
 ## chart OHLC-V
 ## series with talib::chart()
 talib::chart(BTC)

 ## chart indicator
 ## with default values
 talib::indicator(
     talib::double_exponential_moving_average
 )
}

Description

dragonfly_doji() is a generic S3 function that preserves the input class: data.frame in, data.frame out; matrix in, matrix out.

Handling of NA values

Every indicator always emits leading NAs for the initial lookback period - positions where there is not yet enough data to produce a result. This is separate from how NAs already present in the input are handled, which is controlled by the na.bridge argument:

na.bridge = FALSE (default)

The input is passed to the underlying TA-Lib C routine as-is. Because most indicators smooth across time (EMA, RSI, MACD, Bollinger Bands, ...), a single NA in the input typically propagates forward and poisons every subsequent value - it is common for one missing observation to produce an output that is entirely NA from that position onward. This mode is the right choice when you want to see the missing data in the output rather than silently compute around it.

na.bridge = TRUE

NA rows are stripped from the input before the C routine runs; the indicator is computed on the resulting dense series; results are then re-expanded to the original length with NA inserted at every position the input had NA. Output length always matches input length, so the result can be joined back to the source data.frame by row.

Consequence to understand before enabling: bridging causes the indicator to treat non-consecutive observations as consecutive. A 14-period RSI with na.bridge = TRUE over a series containing a month-long gap will compute using 14 observations that span several real-world months as if they were 14 adjacent trading days. For sparse missing values (e.g. a single missing tick) this is harmless; for clustered gaps (e.g. a delisted period, a weekend encoded as NA) the output is correctly aligned by position but economically meaningless across the gap. Inspect gap structure with which(is.na(x)) before enabling on low-quality time series.

Usage

dragonfly_doji(x, cols, na.bridge = FALSE, ...)

Arguments

Details

General options for candlestick pattern recognition:

N

integer. Controls the number of candles to consider when identifying patterns.

alpha

double. A sensitivity parameter when identifying patterns.

Available options and their defaults:

BodyLong

(N = 10, alpha = 1.0). Real body is long when it's longer than the average of the 10 previous candles' real body.

BodyVeryLong

(N = 10, alpha = 3.0). Real body is very long when it's longer than 3 times the average of the 10 previous candles' real body.

BodyShort

(N = 10, alpha = 1.0). Real body is short when it's shorter than the average of the 10 previous candles' real bodies.

BodyDoji

(N = 10, alpha = 0.1). Real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range.

ShadowLong

(N = 0, alpha = 1.0). Shadow is long when it's longer than the real body.

ShadowVeryLong

(N = 0, alpha = 2.0). Shadow is very long when it's longer than 2 times the real body.

ShadowShort

(N = 0, alpha = 1.0). Shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows.

ShadowVeryShort

(N = 10, alpha = 0.1). Shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range.

Near

(N = 5, alpha = 0.2). When measuring distance between parts of candles or width of gaps "near" means "<=20% of the average of the 5 previous candles high low range."

Far

(N = 5, alpha = 0.6). When measuring distance between parts of candles or width of gaps "far" means ">= 60% of the average of the 5 previous candles high-low range."

Equal

(N = 5, alpha = 0.05). When measuring distance between parts of candles or width of gaps "equal" means "<= 5% of the average of the 5 previous candles high-low range."

The options can be modified by running options(talib.BodyLong.N = 5, talib.BodyLong.alpha = 0.2). See vignette("candlestick") for more details.

Value

An object of same class and length of x:

CDLDRAGONFLYDOJI

integer

Pattern codes depend on options(talib.normalize):

• If TRUE: 1 = identified pattern; -1 = identified bearish pattern.

• If FALSE: 100 = identified pattern; -100 = identified bearish pattern.

• 0 = no pattern.

Author(s)

Serkan Korkmaz

See Also

Other Pattern Recognition: abandoned_baby(), advance_block(), belt_hold(), break_away(), closing_marubozu(), concealing_baby_swallow(), counter_attack(), dark_cloud_cover(), doji(), doji_star(), engulfing(), evening_doji_star(), evening_star(), gaps_side_white(), gravestone_doji(), hammer(), hanging_man(), harami(), harami_cross(), high_wave(), hikakke(), hikakke_mod(), homing_pigeon(), in_neck(), inverted_hammer(), kicking(), kicking_baby_length(), ladder_bottom(), long_legged_doji(), long_line(), marubozu(), mat_hold(), matching_low(), morning_doji_star(), morning_star(), on_neck(), piercing(), rickshaw_man(), rise_fall_3_methods(), separating_lines(), shooting_star(), short_line(), spinning_top(), stalled_pattern(), stick_sandwich(), takuri(), tasuki_gap(), three_black_crows(), three_identical_crows(), three_inside(), three_line_strike(), three_outside(), three_stars_in_the_south(), three_white_soldiers(), thrusting(), tristar(), two_crows(), unique_3_river(), upside_gap_2_crows(), xside_gap_3_methods()