Tulip Indicators

https://tulipindicators.org
Admin
Tulip Indicators is a library of 104 functions for technical analysis of financial time series data,...
Tokens:107,446
Snippets:950
Trust Score:7.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### DEMA C Example

Source: https://tulipindicators.org/dema

Demonstrates how to call the DEMA calculation function in C. Requires pre-loaded input data and proper memory allocation for outputs. The output size depends on the input size and the DEMA start offset.

```c
/* Example usage of Double Exponential Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* dema */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_dema_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* dema */

/* Run the actual calculation. */
const int ret = ti_dema(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Crossany Example Usage (C)

Source: https://tulipindicators.org/crossany

Demonstrates how to call the Crossany indicator from C. It includes setup for inputs, options, output allocation, and error checking.

```c
/* Example usage of Crossany */
/* Assuming that 'input1' and 'input2' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {input1, input2};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* crossany */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_crossany_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* crossany */

/* Run the actual calculation. */
const int ret = ti_crossany(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### RSI Calculation Example (C)

Source: https://tulipindicators.org/rsi

Demonstrates how to call the RSI calculation function in C, including input/output setup and memory allocation. Ensure the output array is allocated with sufficient size based on `ti_rsi_start`.

```c
/* Example usage of Relative Strength Index */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* rsi */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_rsi_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* rsi */

/* Run the actual calculation. */
const int ret = ti_rsi(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Example Usage in Lua

Source: https://tulipindicators.org/ppo

Shows an example of how to use the Percentage Price Oscillator (PPO) with Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)
```lua
-- Example usage of Percentage Price Oscillator
ppo = ti.ppo(input, 2, 5)

```
```

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

### C Example Usage

Source: https://tulipindicators.org/dx

Example of how to use the `ti_dx` function in C.

```APIDOC
## Calling From C

```c
/* Example usage of Directional Movement Index */
/* Assuming that 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* dx */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_dx_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* dx */

/* Run the actual calculation. */
const int ret = ti_dx(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Median Price C Usage Example

Source: https://tulipindicators.org/medprice

Demonstrates how to call the median price indicator from C. It includes setup for input arrays, options, output allocation, and error checking.

```c
/* Example usage of Median Price */
/* Assuming that 'high' and 'low' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* medprice */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_medprice_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* medprice */

/* Run the actual calculation. */
const int ret = ti_medprice(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Example Calculation

Source: https://tulipindicators.org/ppo

Provides an example calculation for the Percentage Price Oscillator (PPO) with specific short and long periods.

```APIDOC
## Example Calculation
short period = 2, long period = 5
date| input| ppo  
---|---|---
2005-11-01| 81.59|   
2005-11-02| 81.06| -0.22  
2005-11-03| 82.87| 0.52  
2005-11-04| 83.00| 0.62  
2005-11-07| 83.61| 0.75  
2005-11-08| 83.15| 0.42  
2005-11-09| 82.84| 0.13  
2005-11-10| 83.99| 0.50  
2005-11-11| 84.55| 0.69  
2005-11-14| 84.36| 0.50  
2005-11-15| 85.53| 0.81  
2005-11-16| 86.54| 1.09  
2005-11-17| 86.89| 1.04  
2005-11-18| 87.77| 1.13  
2005-11-21| 87.29| 0.72  
```

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

### Using Indicator Information Structure

Source: https://tulipindicators.org/usage

Once you have a `ti_indicator_info` structure, you can access its members to get the indicator's name, full name, input/option/output counts, and names. The `start` function is called to determine the initial offset for calculations, and the `indicator` function performs the actual computation.

```c
    /* Assuming 'info' is a pointer to a ti_indicator_info structure. */

    /* Get the name (e.g. "sma") and full name (e.g. "Simple Moving Average"). */
    printf("Have indicator %s (%s)\n", info->name, info->full_name);

    /* Get number of inputs, options, outputs. */
    printf("This indicator has %d inputs, %d options, and calculates %d outputs.\n",
            info->inputs, info->options, info->outputs);

    /* The arrays:
            info->input_names contains the names of each expected input
            info->option_names contains the names of each expected option
            info->output_names contains the names of each output
     */

    /* TODO have inputs and options. e.g.
        double *inputs[] = {a, b, c};
        double options[] = {5, 7, 10};
        double *outputs[] = {x, y, z};
     */

    /* Find how much shorter the outputs are than the inputs. */
    const int start = info->start(options);

    /* TODO allocate output array as (size - start) for each output. */

    /* Call the indicator to do the actual calculation. */
    const int r = info->indicator(size, inputs, options, outputs);

    if (r == TI_OKAY) {
        /* It worked, the output arrays have been filled. */
    } else {
        /* Something went wrong. */
    }
```

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

### C Example: Calling Typical Price

Source: https://tulipindicators.org/typprice

Example of how to call the Typical Price indicator from C. Ensure input arrays are pre-loaded and allocate memory for the output.

```c
/* Example usage of Typical Price */
/* Assuming that 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* typprice */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_typprice_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* typprice */

/* Run the actual calculation. */
const int ret = ti_typprice(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Lua Example Usage

Source: https://tulipindicators.org/kvo

Shows a concise example of how to call the Klinger Volume Oscillator using the Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Klinger Volume Oscillator
kvo = ti.kvo(high, low, close, volume, 2, 5)

```
```

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

### DPO Calculation (C Example)

Source: https://tulipindicators.org/dpo

Example of how to use the `ti_dpo_start` and `ti_dpo` functions in C to calculate the Detrended Price Oscillator.

```APIDOC
## Calling From C

### Description
Example usage of Detrended Price Oscillator in C.

### Code Example
```c
/* Example usage of Detrended Price Oscillator */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* dpo */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_dpo_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* dpo */

/* Run the actual calculation. */
const int ret = ti_dpo(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```
```

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

### TRIMA Lua Example Usage

Source: https://tulipindicators.org/trima

Shows a concise example of how to use the TRIMA indicator with Tulip Chart bindings in Lua.

```lua
-- Example usage of Triangular Moving Average
trima = ti.trima(input, 5)

```

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

### Lua Example Usage

Source: https://tulipindicators.org/rocr

An example demonstrating how to use the Rate of Change Ratio indicator with Tulip Chart bindings in Lua.

```APIDOC
-- Example usage of Rate of Change Ratio
rocr = ti.rocr(input, 5)
```

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

### C Example Usage

Source: https://tulipindicators.org/hma

This example demonstrates how to call the `ti_hma` function from C. It shows how to set up input and output arrays, determine the output size, allocate memory, and execute the calculation.

```APIDOC
## Example Usage

### Calling From C

```c
/* Example usage of Hull Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* hma */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_hma_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* hma */

/* Run the actual calculation. */
const int ret = ti_hma(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Lua Example Usage

Source: https://tulipindicators.org/macd

Shows a concise example of how to call the MACD indicator using the Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Moving Average Convergence/Divergence
macd, macd_signal, macd_histogram = ti.macd(input, 2, 5, 9)

```
```

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

### Lua Example Usage

Source: https://tulipindicators.org/dx

Example of how to use the Directional Movement Index with Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Directional Movement Index
dx = ti.dx(high, low, close, 5)

```
```

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

### Example Usage in Lua (Tulip Chart bindings)

Source: https://tulipindicators.org/ema

Shows a concise example of calculating EMA using the Tulip Chart Lua bindings.

```APIDOC
-- Example usage of Exponential Moving Average
ema = ti.ema(input, 5)
```

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

### DPO Calculation (Lua Example)

Source: https://tulipindicators.org/dpo

Example of how to use the Detrended Price Oscillator with Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)

### Description
Example usage of Detrended Price Oscillator with Tulip Chart bindings in Lua.

### Code Example
```lua
-- Example usage of Detrended Price Oscillator
dpo = ti.dpo(input, 5)
```
```

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

### Example Usage (Lua)

Source: https://tulipindicators.org/sqrt

Shows a simple example of how to call the Square Root indicator using Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)
```lua
-- Example usage of Vector Square Root
sqrt = ti.sqrt(input)
```
```

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

### Example Usage in Lua

Source: https://tulipindicators.org/willr

Shows a concise example of how to use the Williams %R indicator with Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Williams %R
willr = ti.willr(high, low, close, 5)

```
```

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

### Example Usage in Lua

Source: https://tulipindicators.org/avgprice

Shows a concise example of how to call the Average Price indicator using Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Average Price
avgprice = ti.avgprice(open, high, low, close)

```
```

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

### Example Usage in Lua

Source: https://tulipindicators.org/dema

Shows a concise example of how to use the DEMA indicator with Tulip Chart's Lua bindings.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Double Exponential Moving Average
dema = ti.dema(input, 5)

```
```

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

### Example Usage in C

Source: https://tulipindicators.org/roc

This C code example demonstrates how to use the `ti_roc_start` and `ti_roc` functions to calculate the Rate of Change indicator. It includes memory allocation and error checking.

```APIDOC
### Calling From C

```c
/* Example usage of Rate of Change */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* roc */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_roc_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* roc */

/* Run the actual calculation. */
const int ret = ti_roc(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Lua Example: Calling Typical Price with Tulip Chart Bindings

Source: https://tulipindicators.org/typprice

Example of how to call the Typical Price indicator using Tulip Chart bindings in Lua.

```lua
-- Example usage of Typical Price
typprice = ti.typprice(high, low, close)

```

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

### Example Usage in C

Source: https://tulipindicators.org/var

Demonstrates how to use the `ti_var_start` and `ti_var` functions in C.

```APIDOC
## Example Usage

### Calling From C

```c
/* Example usage of Variance Over Period */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* var */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_var_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* var */

/* Run the actual calculation. */
const int ret = ti_var(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Lua Example: Calling Directional Indicator

Source: https://tulipindicators.org/di

Example of how to call the Directional Indicator using Tulip Chart bindings in Lua. This demonstrates a concise way to get the plus and minus DI values.

```lua
-- Example usage of Directional Indicator
plus_di, minus_di = ti.di(high, low, close, 5)

```

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

### Mass Index C Example Usage

Source: https://tulipindicators.org/mass

Demonstrates how to call the Mass Index indicator from C code, including input/output setup and error checking.

```c
/* Example usage of Mass Index */
/* Assuming that 'high' and 'low' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* mass */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_mass_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* mass */

/* Run the actual calculation. */
const int ret = ti_mass(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### C Example: Using Vector Floor

Source: https://tulipindicators.org/floor

Demonstrates how to use the Vector Floor function in C. It includes setting up input and output arrays, determining output size using `ti_floor_start`, allocating memory, and executing the `ti_floor` calculation.

```c
/* Example usage of Vector Floor */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* floor */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_floor_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* floor */

/* Run the actual calculation. */
const int ret = ti_floor(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Lua Example Usage (Tulip Chart bindings)

Source: https://tulipindicators.org/wad

A concise example showing how to calculate the Williams Accumulation/Distribution indicator using the `ti.wad` function within the Tulip Chart Lua bindings.

```APIDOC
-- Example usage of Williams Accumulation/Distribution
wad = ti.wad(high, low, close)
```

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

### ti_zlema_start

Source: https://tulipindicators.org/zlema

Initializes the ZLEMA calculation and determines the initial output size based on the provided options.

```APIDOC
## Function Prototype

```c
/* Zero-Lag Exponential Moving Average */
/* Type: overlay */
/* Input arrays: 1    Options: 1    Output arrays: 1 */
/* Inputs: real */
/* Options: period */
/* Outputs: zlema */
int ti_zlema_start(TI_REAL const *options);
```
```

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

### Vector Round C Usage Example

Source: https://tulipindicators.org/round

Demonstrates how to call the Vector Round function from C. It includes setup for input/output arrays, memory allocation, and error checking.

```c
/* Example usage of Vector Round */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* round */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_round_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* round */

/* Run the actual calculation. */
const int ret = ti_round(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### TRIMA C Example Usage

Source: https://tulipindicators.org/trima

Demonstrates how to call the TRIMA function in C. This includes setting up input and options, determining output size, allocating memory, and executing the calculation.

```c
/* Example usage of Triangular Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* trima */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_trima_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* trima */

/* Run the actual calculation. */
const int ret = ti_trima(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Qstick C Example Usage

Source: https://tulipindicators.org/qstick

Demonstrates how to call the Qstick indicator function from C. It includes setting up input arrays, options, allocating output memory, and executing the calculation.

```c
/* Example usage of Qstick */
/* Assuming that 'open' and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {open, close};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* qstick */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_qstick_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* qstick */

/* Run the actual calculation. */
const int ret = ti_qstick(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### C Example Usage

Source: https://tulipindicators.org/vosc

Demonstrates how to use the `ti_vosc_start` and `ti_vosc` functions in C to calculate the Volume Oscillator.

```APIDOC
## Example Usage (C)

### Description
This example shows how to calculate the Volume Oscillator using the Tulip Indicators library in a C program.

### Code
```c
/* Example usage of Volume Oscillator */
/* Assuming that '', and 'volume' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {volume};
TI_REAL options[] = {2, 5}; /* short period, long period */
TI_REAL *outputs[1]; /* vosc */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_vosc_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); 

/* Run the actual calculation. */
const int ret = ti_vosc(in_size, inputs, options, outputs);

```
```

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

### Example Usage in C

Source: https://tulipindicators.org/avgprice

Demonstrates how to use the `ti_avgprice` function in C, including setting up input arrays, options, output arrays, and handling the return value.

```APIDOC
## Calling From C

```c
/* Example usage of Average Price */
/* Assuming that 'open', 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {open, high, low, close};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* avgprice */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_avgprice_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* avgprice */

/* Run the actual calculation. */
const int ret = ti_avgprice(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### ZLEMA C Example Usage

Source: https://tulipindicators.org/zlema

Demonstrates how to call the ZLEMA indicator from C code. This includes setting up input and option arrays, allocating memory for the output, and executing the calculation.

```c
/* Example usage of Zero-Lag Exponential Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* zlema */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_zlema_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* zlema */

/* Run the actual calculation. */
const int ret = ti_zlema(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Lua Example: Calling the AD Indicator with Tulip Chart Bindings

Source: https://tulipindicators.org/ad

A concise example demonstrating how to use the Accumulation/Distribution Line indicator within a Lua environment, leveraging Tulip Chart bindings.

```lua
-- Example usage of Accumulation/Distribution Line
ad = ti.ad(high, low, close, volume)

```

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

### C Example Usage

Source: https://tulipindicators.org/linregslope

Example of how to use the ti_linregslope function in C.

```APIDOC
## Calling From C
```c
/* Example usage of Linear Regression Slope */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* linregslope */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_linregslope_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* linregslope */

/* Run the actual calculation. */
const int ret = ti_linregslope(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Linear Decay - C Example

Source: https://tulipindicators.org/decay

Example of how to use the ti_decay function in C.

```APIDOC
## Calling From C

### Description
Example usage of Linear Decay in C.

### Code
```c
/* Example usage of Linear Decay */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* decay */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_decay_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* decay */

/* Run the actual calculation. */
const int ret = ti_decay(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```
```

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

### Example Usage in C

Source: https://tulipindicators.org/ppo

Demonstrates how to use the Percentage Price Oscillator (PPO) indicator by calling its C functions.

```APIDOC
## Example Usage
### Calling From C
```c
/* Example usage of Percentage Price Oscillator */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {2, 5}; /* short period, long period */
TI_REAL *outputs[1]; /* ppo */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_ppo_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* ppo */

/* Run the actual calculation. */
const int ret = ti_ppo(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Forecast Oscillator (Fosc) - C Example

Source: https://tulipindicators.org/fosc

Example of how to use the ti_fosc function in C.

```APIDOC
## Example Usage - C

### Calling From C
```c
/* Example usage of Forecast Oscillator */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* fosc */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_fosc_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* fosc */

/* Run the actual calculation. */
const int ret = ti_fosc(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### C Example Usage

Source: https://tulipindicators.org/tanh

Example of how to call the Vector Hyperbolic Tangent functions from C code.

```APIDOC
/* Example usage of Vector Hyperbolic Tangent */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* tanh */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_tanh_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* tanh */

/* Run the actual calculation. */
const int ret = ti_tanh(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```

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

### C Example Usage

Source: https://tulipindicators.org/kvo

Demonstrates how to use the `ti_kvo` function in C, including setting up input arrays, options, allocating output memory, and calling the calculation function.

```APIDOC
## Example Usage
### Calling From C

```c
/* Example usage of Klinger Volume Oscillator */
/* Assuming that 'high', 'low', 'close', and 'volume' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close, volume};
TI_REAL options[] = {2, 5}; /* short period, long period */
TI_REAL *outputs[1]; /* kvo */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_kvo_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* kvo */

/* Run the actual calculation. */
const int ret = ti_kvo(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Linear Decay - Lua Example

Source: https://tulipindicators.org/decay

Example of how to use the ti.decay function with Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)

### Description
Example usage of Linear Decay with Tulip Chart bindings in Lua.

### Code
```lua
-- Example usage of Linear Decay
decay = ti.decay(input, 5)
```
```

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

### C Example Usage

Source: https://tulipindicators.org/sma

Demonstrates how to use the `ti_sma_start` and `ti_sma` functions in C to calculate the Simple Moving Average.

```APIDOC
## Example Usage: Calling From C

### Description
This example shows the process of calculating SMA in C, including determining output size, allocating memory, and executing the calculation.

### Code
```c
/* Example usage of Simple Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* sma */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_sma_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* sma */

/* Run the actual calculation. */
const int ret = ti_sma(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```
```

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

### Example Usage in Lua

Source: https://tulipindicators.org/var

Shows an example of using the Variance Over Period indicator with Tulip Chart bindings in Lua.

```APIDOC
### Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Variance Over Period
var = ti.var(input, 5)

```
```

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

### VIDYA C Example Usage

Source: https://tulipindicators.org/vidya

Demonstrates how to call the `ti_vidya` function from C. It includes setting up input and option arrays, determining output size, allocating memory for the output, and executing the calculation.

```c
/* Example usage of Variable Index Dynamic Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {2, 5, .2}; /* short period, long period, alpha */
TI_REAL *outputs[1]; /* vidya */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_vidya_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* vidya */

/* Run the actual calculation. */
const int ret = ti_vidya(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Calling From C

Source: https://tulipindicators.org/min

Example of how to use the `ti_min` function in C, including setting up input and option arrays, allocating output memory, and executing the calculation.

```APIDOC
## Calling From C

```c
/* Example usage of Minimum In Period */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* min */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_min_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* min */

/* Run the actual calculation. */
const int ret = ti_min(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Lua Example for Vector Truncate

Source: https://tulipindicators.org/trunc

Example of how to use the Vector Truncate indicator with Tulip Chart bindings in Lua.

```lua
-- Example usage of Vector Truncate
trunc = ti.trunc(input)

```

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

### ADX Example Usage (C)

Source: https://tulipindicators.org/adx

Demonstrates how to use the ADX indicator in C. It shows setting up input arrays, options, allocating output memory, and calling the ti_adx function.

```c
/* Example usage of Average Directional Movement Index */
/* Assuming that 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* dx */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_adx_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* dx */

/* Run the actual calculation. */
const int ret = ti_adx(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Balance of Power C Example

Source: https://tulipindicators.org/bop

Demonstrates how to call the Balance of Power indicator from C. Requires pre-loaded price arrays and manual memory allocation for the output.

```c
/* Example usage of Balance of Power */
/* Assuming that 'open', 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {open, high, low, close};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* bop */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_bop_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* bop */

/* Run the actual calculation. */
const int ret = ti_bop(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Example Calculation

Source: https://tulipindicators.org/natr

A table showing an example calculation of the Normalized Average True Range indicator over a period of 5.

```APIDOC
## Example Calculation
period = 5
date| high| low| close| natr  
---|---|---|---|---
2005-11-01| 82.15| 81.29| 81.59|   
2005-11-02| 81.89| 80.64| 81.06|   
2005-11-03| 83.03| 81.31| 82.87|   
2005-11-04| 83.30| 82.65| 83.00|   
2005-11-07| 83.85| 83.07| 83.61| 1.34  
2005-11-08| 83.90| 83.11| 83.15| 1.26  
2005-11-09| 83.33| 82.49| 82.84| 1.22  
2005-11-10| 84.30| 82.30| 83.99| 1.44  
2005-11-11| 84.84| 84.15| 84.55| 1.34  
2005-11-14| 85.00| 84.11| 84.36| 1.29  
2005-11-15| 85.90| 84.03| 85.53| 1.45  
2005-11-16| 86.58| 85.39| 86.54| 1.42  
2005-11-17| 86.98| 85.76| 86.89| 1.42  
2005-11-18| 88.00| 87.17| 87.77| 1.37  
2005-11-21| 87.87| 87.01| 87.29| 1.30  
```

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

### Lua Example Usage

Source: https://tulipindicators.org/linregslope

Example of how to use the Linear Regression Slope indicator with Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)
```lua
-- Example usage of Linear Regression Slope
linregslope = ti.linregslope(input, 5)

```
```

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

### C Example Usage

Source: https://tulipindicators.org/macd

Demonstrates how to use the `ti_macd` function in C, including setting up input and output arrays, determining output size, and handling potential errors.

```APIDOC
### Calling From C

```c
/* Example usage of Moving Average Convergence/Divergence */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {2, 5, 9}; /* short period, long period, signal period */
TI_REAL *outputs[3]; /* macd, macd_signal, macd_histogram */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_macd_start(options);

/* Allocate memory for each output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* macd */
outputs[1] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[1] != 0); /* macd_signal */
outputs[2] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[2] != 0); /* macd_histogram */

/* Run the actual calculation. */
const int ret = ti_macd(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```
```

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

### Forecast Oscillator (Fosc) - Lua Example

Source: https://tulipindicators.org/fosc

Example of how to use the Forecast Oscillator with Tulip Chart bindings in Lua.

```APIDOC
## Example Usage - Lua

### Calling From Lua (with Tulip Chart bindings)
```lua
-- Example usage of Forecast Oscillator
fosc = ti.fosc(input, 5)

```
```

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

### C Example Usage

Source: https://tulipindicators.org/adxr

Demonstrates how to call the `ti_adxr` function from C code, including input preparation, option setting, memory allocation, and error checking.

```APIDOC
## Calling From C

### Description
Example usage of Average Directional Movement Rating (ADXR) indicator when calling directly from C.

### Code Example
```c
/* Example usage of Average Directional Movement Rating */
/* Assuming that 'high', 'low', and 'close' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* dx */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_adxr_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* dx */

/* Run the actual calculation. */
const int ret = ti_adxr(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```
```

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

### C Example Usage

Source: https://tulipindicators.org/adosc

Example code demonstrating how to use the `ti_adosc` function in C to calculate the Accumulation/Distribution Oscillator.

```APIDOC
/* Example usage of Accumulation/Distribution Oscillator */
/* Assuming that 'high', 'low', 'close', and 'volume' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, close, volume};
TI_REAL options[] = {2, 5}; /* short period, long period */
TI_REAL *outputs[1]; /* adosc */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_adosc_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* adosc */

/* Run the actual calculation. */
const int ret = ti_adosc(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);

```

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

### TEMA C Example Usage

Source: https://tulipindicators.org/tema

Demonstrates how to call the TEMA calculation function in C. It includes setting up input data, options, allocating output memory, and error checking.

```c
/* Example usage of Triple Exponential Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* tema */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_tema_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* tema */

/* Run the actual calculation. */
const int ret = ti_tema(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Example Usage (C)

Source: https://tulipindicators.org/sqrt

Demonstrates how to use the `ti_sqrt` function in C, including memory allocation and error checking.

```APIDOC
## Calling From C
```c
/* Example usage of Vector Square Root */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* sqrt */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_sqrt_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* sqrt */

/* Run the actual calculation. */
const int ret = ti_sqrt(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```
```

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

### Ease of Movement (EMV) C Example Usage

Source: https://tulipindicators.org/emv

Demonstrates how to call the EMV indicator from C. Requires pre-loaded 'high', 'low', and 'volume' arrays. Memory must be allocated for the output array before calling the calculation function.

```c
/* Example usage of Ease of Movement */
/* Assuming that 'high', 'low', and 'volume' are pre-loaded arrays of size 'in_size'. */
TI_REAL *inputs[] = {high, low, volume};
TI_REAL options[] = {}; /* No options */
TI_REAL *outputs[1]; /* emv */

/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_emv_start(options);

/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* emv */

/* Run the actual calculation. */
const int ret = ti_emv(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

### Fisher Transform Lua Usage Example

Source: https://tulipindicators.org/fisher

Example of how to use the Fisher Transform indicator with Tulip Chart bindings in Lua.

```APIDOC
## Calling From Lua (with Tulip Chart bindings)

```lua
-- Example usage of Fisher Transform
fisher, fisher_signal = ti.fisher(high, low, 5)

```
```
Tokens:
Raw