TA-Lib

https://ta-lib.org/
Admin
TA-Lib is a technical analysis library providing over 200 financial indicators, candlestick...
Tokens:8,520
Snippets:115
Trust Score:9.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Linux Build from Source: Build and Install

Source: https://ta-lib.org/install?q=

Build and install TA-Lib from source on Linux after extracting the source code.

```bash
./configure
make
sudo make install
```

--------------------------------

### macOS Build from Source: Build and Install

Source: https://ta-lib.org/install?q=

Build and install TA-Lib from source on macOS after extracting the source code.

```bash
chmod +x autogen.sh
./autogen.sh
./configure
make
sudo make install
```

--------------------------------

### Linux Install Debian Package

Source: https://ta-lib.org/install?q=

Install TA-Lib using a .deb package on Debian-based Linux distributions.

```bash
# For Intel/AMD (64 bits)
sudo dpkg -i ta-lib_0.6.4_amd64.deb
# or
sudo dpkg -i ta-lib_0.6.4_arm64.deb
# or
sudo dpkg -i ta-lib_0.6.4_i386.deb
```

--------------------------------

### Install TA-Lib with Homebrew on macOS

Source: https://ta-lib.org/install?q=

Recommended installation method for TA-Lib on macOS using the Homebrew package manager.

```bash
brew install ta-lib
```

--------------------------------

### TA_MA Usage Example (30-day SMA)

Source: https://ta-lib.org/api

Example demonstrating how to calculate a 30-day Simple Moving Average (SMA) of daily closing prices using the TA_MA function.

```APIDOC
## TA_MA Usage Example (30-day SMA)

### Description
Calculates a 30-day Simple Moving Average (SMA) of daily closing prices.

### Code Example
```c
TA_Real    closePrice[400];
TA_Real    out[400];
TA_Integer outBeg;
TA_Integer outNbElement;

/* ... initialize closePrice array ... */

retCode = TA_MA( 0, 399,
                 &closePrice[0],
                 30, TA_MAType_SMA,
                 &outBeg, &outNbElement, &out[0] );

/* The output is displayed here */
for( i=0; i < outNbElement; i++ )
   printf( "Day %d = %f\n", outBeg+i, out[i] );
```

### Notes
- The `outBeg` will be 29 and `outNbElement` will be 371 because the moving average is not valid until the 30th day.
- The output array `out[]` will contain valid data starting from index `outBeg`.
```

--------------------------------

### TA_MA Usage Example (14-day EMA for a single bar)

Source: https://ta-lib.org/api

Example demonstrating how to calculate a 14-day Exponential Moving Average (EMA) for a specific price bar.

```APIDOC
## TA_MA Usage Example (14-day EMA for a single bar)

### Description
Calculates a 14-day Exponential Moving Average (EMA) for a single price bar.

### Code Example
```c
TA_Real    closePrice[300];
TA_Real    out;
TA_Integer outBeg;
TA_Integer outNbElement;

/* ... initialize closePrice array ... */

retCode = TA_MA( 299, 299,
                 &closePrice[0],
                 14, TA_MAType_EMA,
                 &outBeg, &outNbElement, &out );
```

### Notes
- In this case, `outBeg` will be 299 and `outNbElement` will be 1.
- If not enough data is provided to calculate even one value, `outNbElement` will be 0.
```

--------------------------------

### Typical TA-Lib Header Locations

Source: https://ta-lib.org/api?q=

Common directories where TA-Lib header files might be found. Adjust the include path based on your installation.

```bash
- /usr/local/include/ta-lib
- /usr/include/ta-lib
- /opt/include/ta-lib
```

--------------------------------

### Link TA-Lib with GCC

Source: https://ta-lib.org/api?q=

Use these GCC options to link the TA-Lib library to your C/C++ project. Ensure TA-Lib is installed and its headers are accessible.

```bash
-I/usr/local/include/ta-lib -lta-lib
```

--------------------------------

### macOS Build from Source: Uninstall

Source: https://ta-lib.org/install?q=

Uninstall TA-Lib when installed from source on macOS.

```bash
sudo make uninstall
```

--------------------------------

### TA_MA Function Signature and Usage

Source: https://ta-lib.org/api?q=

Demonstrates the signature of the TA_MA function for calculating a simple moving average and provides an example of its usage.

```APIDOC
## TA_MA Function

### Description
Calculates the Moving Average for a given price series.

### Function Signature
```c
TA_RetCode TA_MA( int startIdx,
                 int endIdx,
                 const double inReal[],
                 int optInTimePeriod,
                 int optInMAType,
                 int *outBegIdx,
                 int *outNbElement,
                 double outReal[] )
```

### Parameters
*   **startIdx** (int) - The starting index of the input data for calculation.
*   **endIdx** (int) - The ending index of the input data for calculation.
*   **inReal[]** (const double[]) - The input price data array.
*   **optInTimePeriod** (int) - The period for the moving average calculation.
*   **optInMAType** (int) - The type of moving average to calculate (e.g., TA_MAType_SMA, TA_MAType_EMA).
*   **outBegIdx** (int *) - Pointer to store the starting index of the output data.
*   **outNbElement** (int *) - Pointer to store the number of elements in the output data.
*   **outReal[]** (double[]) - The output array to store the calculated moving average values.

### Usage Example
```c
TA_Real    closePrice[400];
TA_Real    out[400];
TA_Integer outBeg;
TA_Integer outNbElement;

/* ... initialize closePrice array ... */

retCode = TA_MA( 0, 399,
                 &closePrice[0],
                 30, TA_MAType_SMA,
                 &outBeg, &outNbElement, &out[0] );

/* Check retCode and process output */
for( i=0; i < outNbElement; i++ )
   printf( "Day %d = %f\n", outBeg+i, out[i] );
```

### Notes
- The output array `outReal` can be the same as one of the input arrays to save memory.
- `outBegIdx` and `outNbElement` provide information about the validity and location of the calculated output data within the `outReal` array.
```

--------------------------------

### Linux Uninstall Debian Package

Source: https://ta-lib.org/install?q=

Uninstall TA-Lib when installed via a .deb package on Linux.

```bash
sudo dpkg -r ta-lib
```

--------------------------------

### Calculate 30-Day Simple Moving Average

Source: https://ta-lib.org/api

Example of calling TA_MA to calculate a 30-day simple moving average (SMA) for daily closing prices. The output array 'out' will contain the results, with 'outBeg' and 'outNbElement' indicating the valid range.

```c
retCode = TA_MA( 0, 399,
                 &closePrice[0],
                 30,TA_MAType_SMA,
                 &outBeg, &outNbElement, &out[0] );
```

--------------------------------

### Calculate 14-Bar Exponential Moving Average for Last Day

Source: https://ta-lib.org/api

Example of calling TA_MA to calculate a 14-bar exponential moving average (EMA) specifically for the last day of the price data. The output will be a single value.

```c
retCode = TA_MA( 299, 299,
                 &closePrice[0],
                 14, TA_MAType_EMA,
                 &outBeg, &outNbElement, &out );
```

--------------------------------

### TA_MA Function Signature

Source: https://ta-lib.org/api

The TA_MA function calculates a simple moving average. It takes input arrays, optional parameters for period and type, and outputs the calculated average along with its start index and element count.

```APIDOC
## TA_MA Function Signature

### Description
Calculates a simple moving average.

### Parameters
- **startIdx** (int) - The starting index for calculation.
- **endIdx** (int) - The ending index for calculation.
- **inReal[]** (const double[]) - Input array of real numbers.
- **optInTimePeriod** (int) - The period for the moving average.
- **optInMAType** (int) - The type of moving average (e.g., SMA, EMA).
- **outBegIdx** (int*) - Pointer to store the starting index of the output array.
- **outNbElement** (int*) - Pointer to store the number of elements in the output array.
- **outReal[]** (double[]) - Output array to store the calculated moving average.
```

--------------------------------

### TA_MA Function Signature

Source: https://ta-lib.org/api?q=

Signature for the TA_MA function, used for calculating moving averages. It takes input arrays, optional parameters like period and type, and outputs the calculated values along with their start index and count.

```c
TA_RetCode TA_MA( 	int 				 startIdx,
							int 				 endIdx,
							const double 	inReal[],
							int 					 optInTimePeriod,
							int 					 optInMAType,
							int 				*outBegIdx,
							int 				  *outNbElement,
							double 				   outReal[]			)

```

--------------------------------

### Windows Build from Source using CMake

Source: https://ta-lib.org/install?q=

Use this command sequence to build TA-Lib from source on Windows using CMake and Visual Studio.

```bash
C:\ta-lib> "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
C:\ta-lib> mkdir build
C:\ta-lib> cd build
C:\ta-lib\build> cmake ..
C:\ta-lib\build> cmake --build .
```

--------------------------------

### Building and Linking TA-Lib

Source: https://ta-lib.org/api?q=

Instructions on how to include TA-Lib headers and link against the TA-Lib library in your C/C++ projects.

```APIDOC
## Building and Linking TA-Lib

In your source code, add **#include "ta_libc.h"** and link to the library named "ta-lib".

You may need to add TA-Lib to your compiler's search path. For example, with gcc, you can use the following options:

```
-I/usr/local/include/ta-lib -lta-lib
```

The paths depend on the method used to install. Typical locations for headers are:

```
- /usr/local/include/ta-lib
- /usr/include/ta-lib
- /opt/include/ta-lib
```

Typical locations for the libraries are:

```
- /usr/lib
- /usr/lib64
- /usr/local/lib
- /usr/local/lib64
- /opt/lib
- /opt/local/lib
```

For homebrew, use **brew --prefix ta-lib** to find the paths.
For windows, look into **C:\Program Files\TA-Lib** for 64-bits and **C:\Program Files (x86)\TA-Lib** for 32-bits.
```

--------------------------------

### Extract and Build TA-Lib from Source on macOS

Source: https://ta-lib.org/install

Steps to extract the TA-Lib source tarball and build it on macOS. This includes setting execute permissions and running the build scripts.

```bash
tar -xzf ta-lib-0.6.4-src.tar.gz
cd ta-lib-0.6.4
```

```bash
chmod +x autogen.sh  # ensure the permissions are set to generate the configure file
./autogen.sh         # generate the configure file
./configure
make
sudo make install
```

--------------------------------

### Re-use Input Buffer for TA_MA Output

Source: https://ta-lib.org/api?q=

Demonstrates how to use the same buffer for both input prices and moving average output to save memory. This is applicable when input and output types are the same.

```c
#define BUFFER_SIZE 100
TA_Real buffer[BUFFER_SIZE];
...
retCode = TA_MA( 0, BUFFER_SIZE-1,
                 &buffer[0],
                 30, TA_MAType_SMA,
                 &outBeg, &outNbElement, &buffer[0] );

```

--------------------------------

### Calculate TA-Lib Output Size: Input Matching

Source: https://ta-lib.org/api

Use this method for simple output array allocation when the exact size is not critical. It ensures enough space by matching the input end index.

```c
allocationSize = endIdx + 1;
```

--------------------------------

### Calculate TA-Lib Output Size: Exact Allocation

Source: https://ta-lib.org/api

This is the optimal allocation method, calculating the precise size needed by considering the function's lookback period. It avoids memory waste but is slightly more complex.

```c
lookback = TA_XXXX_Lookback( ... ) ;
temp = max( lookback, startIdx );
if( temp > endIdx )
allocationSize = 0; // No output
else
allocationSize = endIdx - temp + 1;
```

--------------------------------

### Include TA-Lib Header and Link Library

Source: https://ta-lib.org/api

To use TA-Lib in your C/C++ project, include the 'ta_libc.h' header and link against the 'ta-lib' library. Compiler search paths may need to be configured.

```APIDOC
## Include TA-Lib

In your source code, add **#include "ta_libc.h"** and link to the library named "ta-lib".

### Compiler Flags Example (gcc)
```
-I/usr/local/include/ta-lib -lta-lib
```

### Typical Header Locations
- /usr/local/include/ta-lib
- /usr/include/ta-lib
- /opt/include/ta-lib

### Typical Library Locations
- /usr/lib
- /usr/lib64
- /usr/local/lib
- /usr/local/lib64
- /opt/lib
- /opt/local/lib
```

--------------------------------

### Initialize TA-Lib

Source: https://ta-lib.org/api

Before calling any TA functions, ensure that TA_Initialize has been called once.

```APIDOC
## Initialize TA-Lib

Make sure TA_Initialize was called once (and only once) prior to any other API functions.
```

--------------------------------

### Initialize Data for TA_MA Calculation

Source: https://ta-lib.org/api

Declares the necessary arrays and variables to hold price data and the calculated moving average. Ensure the input array is initialized before calling TA_MA.

```c
TA_Real    closePrice[400];
TA_Real    out[400];
TA_Integer outBeg;
TA_Integer outNbElement;
```

```c
/* ... initialize your closing price here... */
```

--------------------------------

### Initialize Data Structures for TA_MA

Source: https://ta-lib.org/api?q=

Declares the necessary arrays and variables to hold input price data and output results for the TA_MA function.

```c
TA_Real    closePrice[400];
TA_Real    out[400];
TA_Integer outBeg;
TA_Integer outNbElement;

```

--------------------------------

### TA_MA In-place Calculation

Source: https://ta-lib.org/api

Demonstrates how to reuse the input buffer for storing the output of the TA_MA function to save memory.

```APIDOC
## TA_MA In-place Calculation

### Description
Shows how to use the input buffer as the output buffer for TA functions when input and output types are the same.

### Code Example
```c
#define BUFFER_SIZE 100
TA_Real buffer[BUFFER_SIZE];
TA_Integer outBeg;
TA_Integer outNbElement;

/* ... initialize buffer array ... */

retCode = TA_MA( 0, BUFFER_SIZE-1,
                 &buffer[0],
                 30, TA_MAType_SMA,
                 &outBeg, &outNbElement, &buffer[0] );
```

### Notes
- This capability is true for all TA functions where input and output types match.
```

--------------------------------

### Initialize Data Structures for Single-Day EMA Calculation

Source: https://ta-lib.org/api?q=

Declares arrays and variables for calculating a single Exponential Moving Average (EMA) value for the last day of price data.

```c
TA_Real    closePrice[300];
TA_Real    out;
TA_Integer outBeg;
TA_Integer outNbElement;

```

--------------------------------

### macOS Build from Source: Extract Tarball

Source: https://ta-lib.org/install?q=

Extract the TA-Lib source code archive on macOS after downloading.

```bash
tar -xzf ta-lib-0.6.4-src.tar.gz
cd ta-lib-0.6.4
```

--------------------------------

### Typical TA-Lib Library Locations

Source: https://ta-lib.org/api?q=

Common directories where TA-Lib shared or static libraries are located. Adjust the library path as needed.

```bash
- /usr/lib
- /usr/lib64
- /usr/local/lib
- /usr/local/lib64
- /opt/lib
- /opt/local/lib
```

--------------------------------

### Initialize Data for Single-Bar EMA Calculation

Source: https://ta-lib.org/api

Declares arrays and variables for calculating an exponential moving average (EMA) for a single price bar. The output is stored in a single 'TA_Real' variable.

```c
TA_Real    closePrice[300];
TA_Real    out;
TA_Integer outBeg;
TA_Integer outNbElement;
```

```c
/* ... initialize your closing price here... */
```

--------------------------------

### Technical Analysis Functions

Source: https://ta-lib.org/api?q=

Information on how to use the technical analysis functions provided by TA-Lib. It is recommended to call TA_Initialize once before using any other API functions.

```APIDOC
## Technical Analysis Functions

Make sure TA_Initialize was called once (and only once) prior to any other API functions.

All TA functions can be directly called.

Alternatively, an app can call all TA functions using the abstraction layer. This is useful to make dynamic call without knowing at priori the function name or parameters. Example of use is to automatically integrate new functions after upgrading TA-Lib, or for "mutating" calls while strategy searching (e.g. genetic/neural network algo).
```

--------------------------------

### Calculate TA-Lib Output Size: Range Matching

Source: https://ta-lib.org/api

This method allocates memory based on the input range, providing a slightly larger buffer than strictly necessary. It's easy to implement but may waste memory for small ranges.

```c
allocationSize = endIdx - startIdx + 1;
```

--------------------------------

### Display Calculated Moving Average

Source: https://ta-lib.org/api?q=

Iterates through the calculated moving average values and prints them along with their corresponding day index.

```c
for( i=0; i < outNbElement; i++ )
   printf( "Day %d = %f\n", outBeg+i, out[i] );

```

--------------------------------

### Direct Call to TA Functions

Source: https://ta-lib.org/api

All TA functions can be directly called from your C/C++ code after initialization.

```APIDOC
## Direct Call to TA Functions

All TA functions can be directly called.
```

--------------------------------

### Abstraction Layer for TA Functions

Source: https://ta-lib.org/api

An abstraction layer is available to call TA functions dynamically without knowing the function name or parameters beforehand. This is useful for automatic integration of new functions or for dynamic strategy searching.

```APIDOC
## Abstraction Layer

Alternatively, an app can call all TA functions using the abstraction layer. This is useful to make dynamic call without knowing at priori the function name or parameters. Example of use is to automatically integrate new functions after upgrading TA-Lib, or for "mutating" calls while strategy searching (e.g. genetic/neural network algo).
```

--------------------------------

### Call TA_MA for 14-Day EMA on Last Day

Source: https://ta-lib.org/api?q=

Calculates a 14-day Exponential Moving Average (EMA) for a specific day (day 299). The output will contain a single value if sufficient prior data exists.

```c
retCode = TA_MA( 299, 299,
                 &closePrice[0],
                 14, TA_MAType_EMA,
                 &outBeg, &outNbElement, &out );

```

--------------------------------

### TA-Lib MA Function Signature (Double Input)

Source: https://ta-lib.org/api?q=

This is the function signature for the Moving Average (MA) calculation when using double-precision floating-point numbers as input. Ensure the output array is sufficiently sized.

```c
TA_RetCode TA_MA( int     startIdx,
                  int          endIdx,
                  **const double inReal[]**,
                  int          optInTimePeriod,
                  TA_MAType    optInMAType,
                  int         *outBegIdx,
                  int         *outNbElement,
                  double       outReal[] );
```

--------------------------------

### Call TA_MA for 30-Day SMA

Source: https://ta-lib.org/api?q=

Calculates a 30-day Simple Moving Average (SMA) using the TA_MA function. Ensure the input array 'closePrice' is initialized before calling.

```c
retCode = TA_MA( 0, 399,
                 &closePrice[0],
                 30,TA_MAType_SMA,
                 &outBeg, &outNbElement, &out[0] );

```

--------------------------------

### TA-Lib MA Function Signature (Float Input)

Source: https://ta-lib.org/api?q=

This is the function signature for the Moving Average (MA) calculation when using single-precision floating-point numbers as input. The TA_S_ suffix indicates the float input version. Calculations are still performed using doubles internally.

```c
TA_RetCode TA_S_MA( int     startIdx,
                    int          endIdx,
                    **const float inReal[]**,
                    int          optInTimePeriod,
                    TA_MAType    optInMAType,
                    int         *outBegIdx,
                    int         *outNbElement,
                    double       outReal[] );
```

--------------------------------

### TA_MA Function Signature

Source: https://ta-lib.org/api

This is the function signature for TA_MA, used for calculating a simple moving average. It outlines the parameters for input data range, input arrays, optional parameters, and output arrays.

```c
TA_RetCode TA_MA( int startIdx,
                   int endIdx,
                   const double inReal[],
                   int optInTimePeriod,
                   int optInMAType,
                   int *outBegIdx,
                   int *outNbElement,
                   double outReal[] )
```
Tokens:
Raw