defmodule TalibEx do
  @moduledoc """
  Interface for talib
  """
  # Generated File
  alias TalibEx.{Nif, Executer}

  @dialyzer {:nowarn_function, acos: 1}
  @spec acos([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric ACos

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ACOS`
  """
  def acos(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_acos/1)
  end

  @dialyzer {:nowarn_function, ad: 1}
  @spec ad([
          {:high, [number()]} | {:low, [number()]} | {:close, [number()]} | {:volume, [number()]}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Chaikin A/D Line

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `volume`: Volume List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_AD`
  """
  def ad(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:volume, :double_array)
    |> Executer.call(&Nif.nif_ad/4)
  end

  @dialyzer {:nowarn_function, add: 1}
  @spec add([{:values0, [number()]} | {:values1, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Arithmetic Add

  ---
  Inputs
  - `values0`
  - `values1`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ADD`
  """
  def add(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.call(&Nif.nif_add/2)
  end

  @dialyzer {:nowarn_function, adosc: 1}
  @spec adosc([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:volume, [number()]}
          | {:fast_period, pos_integer()}
          | {:slow_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Chaikin A/D Oscillator

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `volume`: Volume List
  - `fast_period` (default `5`): Number of period for the fast MA (between `2` and `100000`)
  - `slow_period` (default `15`): Number of period for the slow MA (between `2` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ADOSC`
  """
  def adosc(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:volume, :double_array)
    |> Executer.load(:fast_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:slow_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.call(&Nif.nif_adosc/6)
  end

  @dialyzer {:nowarn_function, adx: 1}
  @spec adx([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Average Directional Movement Index

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ADX`
  """
  def adx(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_adx/4)
  end

  @dialyzer {:nowarn_function, adxr: 1}
  @spec adxr([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Average Directional Movement Index Rating

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ADXR`
  """
  def adxr(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_adxr/4)
  end

  @dialyzer {:nowarn_function, apo: 1}
  @spec apo([
          {:values, [number()]}
          | {:fast_period, pos_integer()}
          | {:slow_period, pos_integer()}
          | {:moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Absolute Price Oscillator

  ---
  Inputs
  - `values`
  - `fast_period` (default `5`): Number of period for the fast MA (between `2` and `100000`)
  - `slow_period` (default `15`): Number of period for the slow MA (between `2` and `100000`)
  - `moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_APO`
  """
  def apo(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:fast_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:slow_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.load(:moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_apo/4)
  end

  @dialyzer {:nowarn_function, aroon: 1}
  @spec aroon([{:high, [number()]} | {:low, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, down :: [number() | :nan], up :: [number() | :nan]} | {:error, term()}
  @doc """
  Aroon

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `down`: Arron Down
  - `up`: Arron Up

  ---
  TA-LIB src `TA_AROON`
  """
  def aroon(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_aroon/3)
  end

  @dialyzer {:nowarn_function, aroonosc: 1}
  @spec aroonosc([{:high, [number()]} | {:low, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Aroon Oscillator

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_AROONOSC`
  """
  def aroonosc(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_aroonosc/3)
  end

  @dialyzer {:nowarn_function, asin: 1}
  @spec asin([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric ASin

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ASIN`
  """
  def asin(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_asin/1)
  end

  @dialyzer {:nowarn_function, atan: 1}
  @spec atan([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric ATan

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ATAN`
  """
  def atan(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_atan/1)
  end

  @dialyzer {:nowarn_function, atr: 1}
  @spec atr([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Average True Range

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ATR`
  """
  def atr(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_atr/4)
  end

  @dialyzer {:nowarn_function, avgprice: 1}
  @spec avgprice([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Average Price

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_AVGPRICE`
  """
  def avgprice(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_avgprice/4)
  end

  @dialyzer {:nowarn_function, bbands: 1}
  @spec bbands([
          {:values, [number()]}
          | {:time_period, pos_integer()}
          | {:np_dev_up, number()}
          | {:np_dev_down, number()}
          | {:moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) ::
          {:ok, upper :: [number() | :nan], middle :: [number() | :nan],
           lower :: [number() | :nan]}
          | {:error, term()}
  @doc """
  Bollinger Bands

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `np_dev_up`: Deviation multiplier for upper band
  - `np_dev_down`: Deviation multiplier for lower band
  - `moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `upper`: Upper Band
  - `middle`: Middle Band
  - `lower`: Lower Band

  ---
  TA-LIB src `TA_BBANDS`
  """
  def bbands(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:np_dev_up, :double)
    |> Executer.load(:np_dev_down, :double)
    |> Executer.load(:moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_bbands/5)
  end

  @dialyzer {:nowarn_function, beta: 1}
  @spec beta([{:values0, [number()]} | {:values1, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Beta

  ---
  Inputs
  - `values0`
  - `values1`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_BETA`
  """
  def beta(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_beta/3)
  end

  @dialyzer {:nowarn_function, bop: 1}
  @spec bop([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Balance Of Power

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_BOP`
  """
  def bop(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_bop/4)
  end

  @dialyzer {:nowarn_function, cci: 1}
  @spec cci([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Commodity Channel Index

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_CCI`
  """
  def cci(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_cci/4)
  end

  @dialyzer {:nowarn_function, cdl2_crows: 1}
  @spec cdl2_crows([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Two Crows

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL2CROWS`
  """
  def cdl2_crows(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl2_crows/4)
  end

  @dialyzer {:nowarn_function, cdl3_black_crows: 1}
  @spec cdl3_black_crows([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three Black Crows

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3BLACKCROWS`
  """
  def cdl3_black_crows(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_black_crows/4)
  end

  @dialyzer {:nowarn_function, cdl3_inside: 1}
  @spec cdl3_inside([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three Inside Up/Down

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3INSIDE`
  """
  def cdl3_inside(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_inside/4)
  end

  @dialyzer {:nowarn_function, cdl3_line_strike: 1}
  @spec cdl3_line_strike([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three-Line Strike

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3LINESTRIKE`
  """
  def cdl3_line_strike(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_line_strike/4)
  end

  @dialyzer {:nowarn_function, cdl3_outside: 1}
  @spec cdl3_outside([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three Outside Up/Down

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3OUTSIDE`
  """
  def cdl3_outside(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_outside/4)
  end

  @dialyzer {:nowarn_function, cdl3_stars_in_south: 1}
  @spec cdl3_stars_in_south([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three Stars In The South

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3STARSINSOUTH`
  """
  def cdl3_stars_in_south(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_stars_in_south/4)
  end

  @dialyzer {:nowarn_function, cdl3_white_soldiers: 1}
  @spec cdl3_white_soldiers([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Three Advancing White Soldiers

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDL3WHITESOLDIERS`
  """
  def cdl3_white_soldiers(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl3_white_soldiers/4)
  end

  @dialyzer {:nowarn_function, cdl_abandoned_baby: 1}
  @spec cdl_abandoned_baby([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:pentration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Abandoned Baby

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `pentration`: Percentage of penetration of a candle within another candle (minuimum `0`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLABANDONEDBABY`
  """
  def cdl_abandoned_baby(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:pentration, :double, %{min: 0})
    |> Executer.call(&Nif.nif_cdl_abandoned_baby/5)
  end

  @dialyzer {:nowarn_function, cdl_advance_block: 1}
  @spec cdl_advance_block([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Advance Block

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLADVANCEBLOCK`
  """
  def cdl_advance_block(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_advance_block/4)
  end

  @dialyzer {:nowarn_function, cdl_belt_hold: 1}
  @spec cdl_belt_hold([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Belt-hold

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLBELTHOLD`
  """
  def cdl_belt_hold(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_belt_hold/4)
  end

  @dialyzer {:nowarn_function, cdl_breakaway: 1}
  @spec cdl_breakaway([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Breakaway

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLBREAKAWAY`
  """
  def cdl_breakaway(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_breakaway/4)
  end

  @dialyzer {:nowarn_function, cdl_closing_marubozu: 1}
  @spec cdl_closing_marubozu([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Closing Marubozu

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLCLOSINGMARUBOZU`
  """
  def cdl_closing_marubozu(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_closing_marubozu/4)
  end

  @dialyzer {:nowarn_function, cdl_conceal_baby_swallow: 1}
  @spec cdl_conceal_baby_swallow([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Concealing Baby Swallow

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLCONCEALBABYSWALL`
  """
  def cdl_conceal_baby_swallow(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_conceal_baby_swallow/4)
  end

  @dialyzer {:nowarn_function, cdl_counterattack: 1}
  @spec cdl_counterattack([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Counterattack

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLCOUNTERATTACK`
  """
  def cdl_counterattack(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_counterattack/4)
  end

  @dialyzer {:nowarn_function, cdl_dark_cloud_cover: 1}
  @spec cdl_dark_cloud_cover([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:peneration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Dark Cloud Cover

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `peneration`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLDARKCLOUDCOVER`
  """
  def cdl_dark_cloud_cover(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:peneration, :double)
    |> Executer.call(&Nif.nif_cdl_dark_cloud_cover/5)
  end

  @dialyzer {:nowarn_function, cdl_doji: 1}
  @spec cdl_doji([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Doji

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLDOJI`
  """
  def cdl_doji(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_doji/4)
  end

  @dialyzer {:nowarn_function, cdl_doji_star: 1}
  @spec cdl_doji_star([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Doji Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLDOJISTAR`
  """
  def cdl_doji_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_doji_star/4)
  end

  @dialyzer {:nowarn_function, cdl_dragonfly_doji: 1}
  @spec cdl_dragonfly_doji([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Dragonfly Doji

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLDRAGONFLYDOJI`
  """
  def cdl_dragonfly_doji(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_dragonfly_doji/4)
  end

  @dialyzer {:nowarn_function, cdl_engulfing: 1}
  @spec cdl_engulfing([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Engulfing Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLENGULFING`
  """
  def cdl_engulfing(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_engulfing/4)
  end

  @dialyzer {:nowarn_function, cdl_evening_doji_star: 1}
  @spec cdl_evening_doji_star([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:peneration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Evening Doji Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `peneration`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLEVENINGDOJISTAR`
  """
  def cdl_evening_doji_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:peneration, :double)
    |> Executer.call(&Nif.nif_cdl_evening_doji_star/5)
  end

  @dialyzer {:nowarn_function, cdl_evening_star: 1}
  @spec cdl_evening_star([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:peneration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Evening Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `peneration`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLEVENINGSTAR`
  """
  def cdl_evening_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:peneration, :double)
    |> Executer.call(&Nif.nif_cdl_evening_star/5)
  end

  @dialyzer {:nowarn_function, cdl_gap_side_side_white: 1}
  @spec cdl_gap_side_side_white([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Up/Down-gap side-by-side white lines

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLGAPSIDESIDEWHITE`
  """
  def cdl_gap_side_side_white(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_gap_side_side_white/4)
  end

  @dialyzer {:nowarn_function, cdl_gravestone_doji: 1}
  @spec cdl_gravestone_doji([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Gravestone Doji

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLGRAVESTONEDOJI`
  """
  def cdl_gravestone_doji(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_gravestone_doji/4)
  end

  @dialyzer {:nowarn_function, cdl_hammer: 1}
  @spec cdl_hammer([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Hammer

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHAMMER`
  """
  def cdl_hammer(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_hammer/4)
  end

  @dialyzer {:nowarn_function, cdl_hanging_man: 1}
  @spec cdl_hanging_man([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Hanging Man

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHANGINGMAN`
  """
  def cdl_hanging_man(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_hanging_man/4)
  end

  @dialyzer {:nowarn_function, cdl_harami: 1}
  @spec cdl_harami([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Harami Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHARAMI`
  """
  def cdl_harami(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_harami/4)
  end

  @dialyzer {:nowarn_function, cdl_harami_cross: 1}
  @spec cdl_harami_cross([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Harami Cross Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHARAMICROSS`
  """
  def cdl_harami_cross(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_harami_cross/4)
  end

  @dialyzer {:nowarn_function, cdl_highwave: 1}
  @spec cdl_highwave([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  High-Wave Candle

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHIGHWAVE`
  """
  def cdl_highwave(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_highwave/4)
  end

  @dialyzer {:nowarn_function, cdl_hikkake: 1}
  @spec cdl_hikkake([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Hikkake Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHIKKAKE`
  """
  def cdl_hikkake(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_hikkake/4)
  end

  @dialyzer {:nowarn_function, cdl_hikkake_mod: 1}
  @spec cdl_hikkake_mod([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Modified Hikkake Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHIKKAKEMOD`
  """
  def cdl_hikkake_mod(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_hikkake_mod/4)
  end

  @dialyzer {:nowarn_function, cdl_homing_pigeon: 1}
  @spec cdl_homing_pigeon([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Homing Pigeon

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLHOMINGPIGEON`
  """
  def cdl_homing_pigeon(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_homing_pigeon/4)
  end

  @dialyzer {:nowarn_function, cdl_identical_3_crows: 1}
  @spec cdl_identical_3_crows([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Identical Three Crows

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLIDENTICAL3CROWS`
  """
  def cdl_identical_3_crows(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_identical_3_crows/4)
  end

  @dialyzer {:nowarn_function, cdl_inneck: 1}
  @spec cdl_inneck([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  In-Neck Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLINNECK`
  """
  def cdl_inneck(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_inneck/4)
  end

  @dialyzer {:nowarn_function, cdl_inverted_hammer: 1}
  @spec cdl_inverted_hammer([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Inverted Hammer

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLINVERTEDHAMMER`
  """
  def cdl_inverted_hammer(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_inverted_hammer/4)
  end

  @dialyzer {:nowarn_function, cdl_kicking: 1}
  @spec cdl_kicking([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Kicking

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLKICKING`
  """
  def cdl_kicking(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_kicking/4)
  end

  @dialyzer {:nowarn_function, cdl_kicking_by_length: 1}
  @spec cdl_kicking_by_length([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Kicking - bull/bear determined by the longer marubozu

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLKICKINGBYLENGTH`
  """
  def cdl_kicking_by_length(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_kicking_by_length/4)
  end

  @dialyzer {:nowarn_function, cdl_ladder_bottom: 1}
  @spec cdl_ladder_bottom([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Ladder Bottom

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLLADDERBOTTOM`
  """
  def cdl_ladder_bottom(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_ladder_bottom/4)
  end

  @dialyzer {:nowarn_function, cdl_long_legged_doji: 1}
  @spec cdl_long_legged_doji([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Long Legged Doji

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLLONGLEGGEDDOJI`
  """
  def cdl_long_legged_doji(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_long_legged_doji/4)
  end

  @dialyzer {:nowarn_function, cdl_long_line: 1}
  @spec cdl_long_line([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Long Line Candle

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLLONGLINE`
  """
  def cdl_long_line(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_long_line/4)
  end

  @dialyzer {:nowarn_function, cdl_marubozu: 1}
  @spec cdl_marubozu([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Marubozu

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLMARUBOZU`
  """
  def cdl_marubozu(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_marubozu/4)
  end

  @dialyzer {:nowarn_function, cdl_matching_low: 1}
  @spec cdl_matching_low([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Matching Low

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLMATCHINGLOW`
  """
  def cdl_matching_low(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_matching_low/4)
  end

  @dialyzer {:nowarn_function, cdl_mat_hold: 1}
  @spec cdl_mat_hold([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:pentration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Mat Hold

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `pentration`: Percentage of penetration of a candle within another candle (minuimum `0`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLMATHOLD`
  """
  def cdl_mat_hold(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:pentration, :double, %{min: 0})
    |> Executer.call(&Nif.nif_cdl_mat_hold/5)
  end

  @dialyzer {:nowarn_function, cdl_morning_doji_star: 1}
  @spec cdl_morning_doji_star([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:pentration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Morning Doji Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `pentration`: Percentage of penetration of a candle within another candle (minuimum `0`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLMORNINGDOJISTAR`
  """
  def cdl_morning_doji_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:pentration, :double, %{min: 0})
    |> Executer.call(&Nif.nif_cdl_morning_doji_star/5)
  end

  @dialyzer {:nowarn_function, cdl_morning_star: 1}
  @spec cdl_morning_star([
          {:open, [number()]}
          | {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:pentration, number()}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Morning Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `pentration`: Percentage of penetration of a candle within another candle (minuimum `0`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLMORNINGSTAR`
  """
  def cdl_morning_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:pentration, :double, %{min: 0})
    |> Executer.call(&Nif.nif_cdl_morning_star/5)
  end

  @dialyzer {:nowarn_function, cdl_on_neck: 1}
  @spec cdl_on_neck([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  On-Neck Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLONNECK`
  """
  def cdl_on_neck(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_on_neck/4)
  end

  @dialyzer {:nowarn_function, cdl_piercing: 1}
  @spec cdl_piercing([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Piercing Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLPIERCING`
  """
  def cdl_piercing(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_piercing/4)
  end

  @dialyzer {:nowarn_function, cdl_rickshaw_man: 1}
  @spec cdl_rickshaw_man([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Rickshaw Man

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLRICKSHAWMAN`
  """
  def cdl_rickshaw_man(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_rickshaw_man/4)
  end

  @dialyzer {:nowarn_function, cdl_rise_fall_3_methods: 1}
  @spec cdl_rise_fall_3_methods([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Rickshaw Man

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLRISEFALL3METHODS`
  """
  def cdl_rise_fall_3_methods(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_rise_fall_3_methods/4)
  end

  @dialyzer {:nowarn_function, cdl_separating_lines: 1}
  @spec cdl_separating_lines([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Separating Lines

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSEPARATINGLINES`
  """
  def cdl_separating_lines(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_separating_lines/4)
  end

  @dialyzer {:nowarn_function, cdl_shooting_star: 1}
  @spec cdl_shooting_star([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Shooting Star

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSHOOTINGSTAR`
  """
  def cdl_shooting_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_shooting_star/4)
  end

  @dialyzer {:nowarn_function, cdl_short_line: 1}
  @spec cdl_short_line([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Short Line Candle

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSHORTLINE`
  """
  def cdl_short_line(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_short_line/4)
  end

  @dialyzer {:nowarn_function, cdl_spinning_top: 1}
  @spec cdl_spinning_top([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Spinning Top

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSPINNINGTOP`
  """
  def cdl_spinning_top(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_spinning_top/4)
  end

  @dialyzer {:nowarn_function, cdl_stalled_pattern: 1}
  @spec cdl_stalled_pattern([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Stalled Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSTALLEDPATTERN`
  """
  def cdl_stalled_pattern(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_stalled_pattern/4)
  end

  @dialyzer {:nowarn_function, cdl_stick_sandwich: 1}
  @spec cdl_stick_sandwich([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Stick Sandwich

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLSTICKSANDWICH`
  """
  def cdl_stick_sandwich(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_stick_sandwich/4)
  end

  @dialyzer {:nowarn_function, cdl_takuri: 1}
  @spec cdl_takuri([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Takuri (Dragonfly Doji with very long lower shadow)

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLTAKURI`
  """
  def cdl_takuri(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_takuri/4)
  end

  @dialyzer {:nowarn_function, cdl_tasuki_gap: 1}
  @spec cdl_tasuki_gap([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Tasuki Gap

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLTASUKIGAP`
  """
  def cdl_tasuki_gap(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_tasuki_gap/4)
  end

  @dialyzer {:nowarn_function, cdl_thrusting: 1}
  @spec cdl_thrusting([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Thrusting Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLTHRUSTING`
  """
  def cdl_thrusting(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_thrusting/4)
  end

  @dialyzer {:nowarn_function, cdl_tri_star: 1}
  @spec cdl_tri_star([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Tristar Pattern

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLTRISTAR`
  """
  def cdl_tri_star(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_tri_star/4)
  end

  @dialyzer {:nowarn_function, cdl_unique_3_river: 1}
  @spec cdl_unique_3_river([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Unique 3 River

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLUNIQUE3RIVER`
  """
  def cdl_unique_3_river(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_unique_3_river/4)
  end

  @dialyzer {:nowarn_function, cdl_upside_gap_2_crows: 1}
  @spec cdl_upside_gap_2_crows([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Upside Gap Two Crows

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLUPSIDEGAP2CROWS`
  """
  def cdl_upside_gap_2_crows(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_upside_gap_2_crows/4)
  end

  @dialyzer {:nowarn_function, cdl_upside_downside_gap_3_methods: 1}
  @spec cdl_upside_downside_gap_3_methods([
          {:open, [number()]} | {:high, [number()]} | {:low, [number()]} | {:close, [number()]}
        ]) :: {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Upside/Downside Gap Three Methods

  ---
  Inputs
  - `open`: Open Price List
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_CDLXSIDEGAP3METHODS`
  """
  def cdl_upside_downside_gap_3_methods(params) do
    params
    |> Executer.new()
    |> Executer.load(:open, :double_array)
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_cdl_upside_downside_gap_3_methods/4)
  end

  @dialyzer {:nowarn_function, ceil: 1}
  @spec ceil([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Ceil

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_CEIL`
  """
  def ceil(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ceil/1)
  end

  @dialyzer {:nowarn_function, cmo: 1}
  @spec cmo([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Chande Momentum Oscillator

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_CMO`
  """
  def cmo(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_cmo/2)
  end

  @dialyzer {:nowarn_function, correl: 1}
  @spec correl([{:values0, [number()]} | {:values1, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Pearson's Correlation Coefficient (r)

  ---
  Inputs
  - `values0`
  - `values1`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_CORREL`
  """
  def correl(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_correl/3)
  end

  @dialyzer {:nowarn_function, cos: 1}
  @spec cos([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Cos

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_COS`
  """
  def cos(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_cos/1)
  end

  @dialyzer {:nowarn_function, cosh: 1}
  @spec cosh([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Cosh

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_COSH`
  """
  def cosh(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_cosh/1)
  end

  @dialyzer {:nowarn_function, dema: 1}
  @spec dema([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Double Exponential Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_DEMA`
  """
  def dema(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_dema/2)
  end

  @dialyzer {:nowarn_function, div: 1}
  @spec div([{:values0, [number()]} | {:values1, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Arithmetic Div

  ---
  Inputs
  - `values0`
  - `values1`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_DIV`
  """
  def div(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.call(&Nif.nif_div/2)
  end

  @dialyzer {:nowarn_function, dx: 1}
  @spec dx([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Directional Movement Index

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_DX`
  """
  def dx(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_dx/4)
  end

  @dialyzer {:nowarn_function, ema: 1}
  @spec ema([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Exponential Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_EMA`
  """
  def ema(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_ema/2)
  end

  @dialyzer {:nowarn_function, exp: 1}
  @spec exp([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Arithmetic Exp

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_EXP`
  """
  def exp(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_exp/1)
  end

  @dialyzer {:nowarn_function, floor: 1}
  @spec floor([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Floor

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_FLOOR`
  """
  def floor(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_floor/1)
  end

  @dialyzer {:nowarn_function, ht_dcperiod: 1}
  @spec ht_dcperiod([{:values, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - Dominant Cycle Period

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_HT_DCPERIOD`
  """
  def ht_dcperiod(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_dcperiod/1)
  end

  @dialyzer {:nowarn_function, ht_dcphase: 1}
  @spec ht_dcphase([{:values, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - Dominant Cycle Phase

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_HT_DCPHASE`
  """
  def ht_dcphase(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_dcphase/1)
  end

  @dialyzer {:nowarn_function, ht_phasor: 1}
  @spec ht_phasor([{:values, [number()]}]) ::
          {:ok, in_phase :: [number() | :nan], quadrature :: [number() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - Phasor Components

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `in_phase`
  - `quadrature`

  ---
  TA-LIB src `TA_HT_PHASOR`
  """
  def ht_phasor(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_phasor/1)
  end

  @dialyzer {:nowarn_function, ht_sine: 1}
  @spec ht_sine([{:values, [number()]}]) ::
          {:ok, sine :: [number() | :nan], leadSine :: [number() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - SineWave

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `sine`
  - `leadSine`

  ---
  TA-LIB src `TA_HT_SINE`
  """
  def ht_sine(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_sine/1)
  end

  @dialyzer {:nowarn_function, ht_trendline: 1}
  @spec ht_trendline([{:values, [number()]}]) ::
          {:ok, list :: [number() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - Instantaneous Trendline

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_HT_TRENDLINE`
  """
  def ht_trendline(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_trendline/1)
  end

  @dialyzer {:nowarn_function, ht_trendmode: 1}
  @spec ht_trendmode([{:values, [number()]}]) ::
          {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Hilbert Transform - Trend vs Cycle Mode

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_HT_TRENDMODE`
  """
  def ht_trendmode(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ht_trendmode/1)
  end

  @dialyzer {:nowarn_function, kama: 1}
  @spec kama([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Kaufman Adaptive Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_KAMA`
  """
  def kama(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_kama/2)
  end

  @dialyzer {:nowarn_function, linear_reg: 1}
  @spec linear_reg([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Linear Regression

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LINEARREG`
  """
  def linear_reg(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_linear_reg/2)
  end

  @dialyzer {:nowarn_function, linear_reg_angle: 1}
  @spec linear_reg_angle([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Linear Regression Angle

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LINEARREG_ANGLE`
  """
  def linear_reg_angle(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_linear_reg_angle/2)
  end

  @dialyzer {:nowarn_function, linear_reg_intercept: 1}
  @spec linear_reg_intercept([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Linear Regression Intercept

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LINEARREG_INTERCEPT`
  """
  def linear_reg_intercept(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_linear_reg_intercept/2)
  end

  @dialyzer {:nowarn_function, linear_reg_slope: 1}
  @spec linear_reg_slope([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Linear Regression Slope

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LINEARREG_SLOPE`
  """
  def linear_reg_slope(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_linear_reg_slope/2)
  end

  @dialyzer {:nowarn_function, ln: 1}
  @spec ln([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Log Natural

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LN`
  """
  def ln(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_ln/1)
  end

  @dialyzer {:nowarn_function, log10: 1}
  @spec log10([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Log10

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_LOG10`
  """
  def log10(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_log10/1)
  end

  @dialyzer {:nowarn_function, ma: 1}
  @spec ma([
          {:values, [number()]}
          | {:time_period, pos_integer()}
          | {:moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Moving average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MA`
  """
  def ma(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_ma/3)
  end

  @dialyzer {:nowarn_function, macd: 1}
  @spec macd([
          {:values, [number()]}
          | {:fast_period, pos_integer()}
          | {:slow_period, pos_integer()}
          | {:signal_period, pos_integer()}
        ]) ::
          {:ok, macd :: [number() | :nan], macd_signal :: [number() | :nan],
           macd_hist :: [number() | :nan]}
          | {:error, term()}
  @doc """
  Moving Average Convergence/Divergence

  ---
  Inputs
  - `values`
  - `fast_period` (default `5`): Number of period for the fast MA (between `2` and `100000`)
  - `slow_period` (default `15`): Number of period for the slow MA (between `2` and `100000`)
  - `signal_period` (default `1`): Smoothing for the signal line (between `1` and `100000`)

  ---
  Outputs
  - `macd`
  - `macd_signal`
  - `macd_hist`

  ---
  TA-LIB src `TA_MACD`
  """
  def macd(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:fast_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:slow_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.load(:signal_period, :integer, %{default: 1, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_macd/4)
  end

  @dialyzer {:nowarn_function, macdext: 1}
  @spec macdext([
          {:values, [number()]}
          | {:fast_period, pos_integer()}
          | {:fast_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
          | {:slow_period, pos_integer()}
          | {:slow_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
          | {:signal_period, pos_integer()}
          | {:single_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) ::
          {:ok, macd :: [number() | :nan], macd_signal :: [number() | :nan],
           macd_hist :: [number() | :nan]}
          | {:error, term()}
  @doc """
  MACD with controllable MA type

  ---
  Inputs
  - `values`
  - `fast_period` (default `5`): Number of period for the fast MA (between `2` and `100000`)
  - `fast_moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`
  - `slow_period` (default `15`): Number of period for the slow MA (between `2` and `100000`)
  - `slow_moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`
  - `signal_period` (default `1`): Smoothing for the signal line (between `1` and `100000`)
  - `single_moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `macd`
  - `macd_signal`
  - `macd_hist`

  ---
  TA-LIB src `TA_MACDEXT`
  """
  def macdext(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:fast_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:fast_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.load(:slow_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.load(:slow_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.load(:signal_period, :integer, %{default: 1, min: 1, max: 100_000})
    |> Executer.load(:single_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_macdext/7)
  end

  @dialyzer {:nowarn_function, macdfix: 1}
  @spec macdfix([{:values, [number()]} | {:signal_period, pos_integer()}]) ::
          {:ok, macd :: [number() | :nan], macd_signal :: [number() | :nan],
           macd_hist :: [number() | :nan]}
          | {:error, term()}
  @doc """
  Moving Average Convergence/Divergence Fix 12/26

  ---
  Inputs
  - `values`
  - `signal_period` (default `1`): Smoothing for the signal line (between `1` and `100000`)

  ---
  Outputs
  - `macd`
  - `macd_signal`
  - `macd_hist`

  ---
  TA-LIB src `TA_MACDFIX`
  """
  def macdfix(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:signal_period, :integer, %{default: 1, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_macdfix/2)
  end

  @dialyzer {:nowarn_function, mama: 1}
  @spec mama([{:values, [number()]} | {:fast_limit, number()} | {:slow_limit, number()}]) ::
          {:ok, mama :: [number() | :nan], fama :: [number() | :nan]} | {:error, term()}
  @doc """
  MESA Adaptive Moving Average

  ---
  Inputs
  - `values`
  - `fast_limit` (default `0.75`): Upper limit use in the adaptive algorithm (between `0.01` and `0.99`)
  - `slow_limit` (default `0.25`): Lower limit use in the adaptive algorithm (between `0.01` and `0.99`)

  ---
  Outputs
  - `mama`
  - `fama`

  ---
  TA-LIB src `TA_MAMA`
  """
  def mama(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:fast_limit, :double, %{default: 0.75, min: 0.01, max: 0.99})
    |> Executer.load(:slow_limit, :double, %{default: 0.25, min: 0.01, max: 0.99})
    |> Executer.call(&Nif.nif_mama/3)
  end

  @dialyzer {:nowarn_function, mavp: 1}
  @spec mavp([
          {:values, [number()]}
          | {:periods, [number()]}
          | {:min_period, pos_integer()}
          | {:max_period, pos_integer()}
          | {:moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, list :: [number() | :nan]} | {:error, term()}
  @doc """
  Moving average with variable period

  ---
  Inputs
  - `values`
  - `periods`
  - `min_period` (default `5`): Value less than minimum will be changed to Minimum period (between `2` and `100000`)
  - `max_period` (default `15`): Value higher than maximum will be changed to Maximum period (between `2` and `100000`)
  - `moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MAVP`
  """
  def mavp(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:periods, :double_array)
    |> Executer.load(:min_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:max_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.load(:moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_mavp/5)
  end

  @dialyzer {:nowarn_function, max: 1}
  @spec max([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Highest value over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MAX`
  """
  def max(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_max/2)
  end

  @dialyzer {:nowarn_function, max_index: 1}
  @spec max_index([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Index of highest value over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MAXINDEX`
  """
  def max_index(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_max_index/2)
  end

  @dialyzer {:nowarn_function, med_price: 1}
  @spec med_price([{:high, [number()]} | {:low, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Median Price

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MEDPRICE`
  """
  def med_price(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.call(&Nif.nif_med_price/2)
  end

  @dialyzer {:nowarn_function, mfi: 1}
  @spec mfi([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:volume, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Money Flow Index

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `volume`: Volume List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MFI`
  """
  def mfi(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:volume, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_mfi/5)
  end

  @dialyzer {:nowarn_function, mid_point: 1}
  @spec mid_point([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  MidPoint over period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MIDPOINT`
  """
  def mid_point(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_mid_point/2)
  end

  @dialyzer {:nowarn_function, mid_price: 1}
  @spec mid_price([{:high, [number()]} | {:low, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Midpoint Price over period

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MIDPRICE`
  """
  def mid_price(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_mid_price/3)
  end

  @dialyzer {:nowarn_function, min: 1}
  @spec min([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Lowest value over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MIN`
  """
  def min(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_min/2)
  end

  @dialyzer {:nowarn_function, min_index: 1}
  @spec min_index([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, list :: [integer() | :nan]} | {:error, term()}
  @doc """
  Index of lowest value over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MININDEX`
  """
  def min_index(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_min_index/2)
  end

  @dialyzer {:nowarn_function, min_max: 1}
  @spec min_max([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, min :: [number() | :nan], max :: [number() | :nan]} | {:error, term()}
  @doc """
  Lowest and highest values over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `min`
  - `max`

  ---
  TA-LIB src `TA_MINMAX`
  """
  def min_max(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_min_max/2)
  end

  @dialyzer {:nowarn_function, min_max_index: 1}
  @spec min_max_index([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, min :: [integer() | :nan], max :: [integer() | :nan]} | {:error, term()}
  @doc """
  Indexes of lowest and highest values over a specified period

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `min`
  - `max`

  ---
  TA-LIB src `TA_MINMAXINDEX`
  """
  def min_max_index(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_min_max_index/2)
  end

  @dialyzer {:nowarn_function, minus_di: 1}
  @spec minus_di([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, list :: [number() | :nan]} | {:error, term()}
  @doc """
  Minus Directional Indicator

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MINUS_DI`
  """
  def minus_di(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_minus_di/4)
  end

  @dialyzer {:nowarn_function, minus_dm: 1}
  @spec minus_dm([{:high, [number()]} | {:low, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, list :: [number() | :nan]} | {:error, term()}
  @doc """
  Minus Directional Movement

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MINUS_DM`
  """
  def minus_dm(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_minus_dm/3)
  end

  @dialyzer {:nowarn_function, mom: 1}
  @spec mom([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, list :: [number() | :nan]} | {:error, term()}
  @doc """
  Momentum

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `list`

  ---
  TA-LIB src `TA_MOM`
  """
  def mom(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_mom/2)
  end

  @dialyzer {:nowarn_function, mult: 1}
  @spec mult([{:values0, [number()]} | {:values1, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Arithmetic Mult

  ---
  Inputs
  - `values0`
  - `values1`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_MULT`
  """
  def mult(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.call(&Nif.nif_mult/2)
  end

  @dialyzer {:nowarn_function, natr: 1}
  @spec natr([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Normalized Average True Range

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_NATR`
  """
  def natr(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_natr/4)
  end

  @dialyzer {:nowarn_function, obv: 1}
  @spec obv([{:values, [number()]} | {:volume, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  On Balance Volume

  ---
  Inputs
  - `values`
  - `volume`: Volume List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_OBV`
  """
  def obv(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:volume, :double_array)
    |> Executer.call(&Nif.nif_obv/2)
  end

  @dialyzer {:nowarn_function, plus_di: 1}
  @spec plus_di([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Plus Directional Indicator

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_PLUS_DI`
  """
  def plus_di(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_plus_di/4)
  end

  @dialyzer {:nowarn_function, plus_dm: 1}
  @spec plus_dm([{:high, [number()]} | {:low, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Plus Directional Movement

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_PLUS_DM`
  """
  def plus_dm(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_plus_dm/3)
  end

  @dialyzer {:nowarn_function, ppo: 1}
  @spec ppo([
          {:values, [number()]}
          | {:fast_period, pos_integer()}
          | {:slow_period, pos_integer()}
          | {:moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Percentage Price Oscillator

  ---
  Inputs
  - `values`
  - `fast_period` (default `5`): Number of period for the fast MA (between `2` and `100000`)
  - `slow_period` (default `15`): Number of period for the slow MA (between `2` and `100000`)
  - `moving_average_type` (default `:sma`): Type of moving average. `sma` | `ema` | `wma` | `dema` | `tema` | `trima` | `kama` | `mama` | `t3`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_PPO`
  """
  def ppo(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:fast_period, :integer, %{default: 5, min: 2, max: 100_000})
    |> Executer.load(:slow_period, :integer, %{default: 15, min: 2, max: 100_000})
    |> Executer.load(:moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_ppo/4)
  end

  @dialyzer {:nowarn_function, roc: 1}
  @spec roc([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Rate of change : ((price/prevPrice)-1)*100

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ROC`
  """
  def roc(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_roc/2)
  end

  @dialyzer {:nowarn_function, rocp: 1}
  @spec rocp([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Rate of change Percentage: (price-prevPrice)/prevPrice

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ROCP`
  """
  def rocp(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_rocp/2)
  end

  @dialyzer {:nowarn_function, rocr: 1}
  @spec rocr([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Rate of change ratio: (price/prevPrice)

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ROCR`
  """
  def rocr(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_rocr/2)
  end

  @dialyzer {:nowarn_function, rocr100: 1}
  @spec rocr100([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Rate of change ratio 100 scale: (price/prevPrice)*100

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ROCR100`
  """
  def rocr100(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_rocr100/2)
  end

  @dialyzer {:nowarn_function, rsi: 1}
  @spec rsi([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Relative Strength Index

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_RSI`
  """
  def rsi(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_rsi/2)
  end

  @dialyzer {:nowarn_function, sar: 1}
  @spec sar([
          {:high, [number()]}
          | {:low, [number()]}
          | {:acceleration, number()}
          | {:maximum, number()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Parabolic SAR

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `acceleration` (default `0`): Acceleration Factor used up to the Maximum value (minuimum `0`)
  - `maximum` (default `0`): Acceleration Factor Maximum value (minuimum `0`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SAR`
  """
  def sar(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:acceleration, :double, %{default: 0, min: 0})
    |> Executer.load(:maximum, :double, %{default: 0, min: 0})
    |> Executer.call(&Nif.nif_sar/4)
  end

  @dialyzer {:nowarn_function, sarext: 1}
  @spec sarext([
          {:high, [number()]}
          | {:low, [number()]}
          | {:start_value, number()}
          | {:offset_on_reverse, number()}
          | {:acceleration_init_long, number()}
          | {:acceleration_long, number()}
          | {:acceleration_max_long, number()}
          | {:acceleration_init_short, number()}
          | {:acceleration_short, number()}
          | {:acceleration_max_short, number()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Parabolic SAR - Extended

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `start_value` (default `0`): Start value and direction. 0 for Auto, >0 for Long, <0 for Short
  - `offset_on_reverse` (default `0`): Percent offset added/removed to initial stop on short/long reversal (minuimum `0`)
  - `acceleration_init_long` (default `0`): Acceleration Factor initial value for the Long direction (minuimum `0`)
  - `acceleration_long` (default `0`): Acceleration Factor for the Long direction (minuimum `0`)
  - `acceleration_max_long` (default `0`): Acceleration Factor maximum value for the Long direction (minuimum `0`)
  - `acceleration_init_short` (default `0`): Acceleration Factor initial value for the Short direction (minuimum `0`)
  - `acceleration_short` (default `0`): Acceleration Factor for the Short direction (minuimum `0`)
  - `acceleration_max_short` (default `0`): Acceleration Factor maximum value for the Short direction (minuimum `0`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SAREXT`
  """
  def sarext(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:start_value, :double, %{default: 0})
    |> Executer.load(:offset_on_reverse, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_init_long, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_long, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_max_long, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_init_short, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_short, :double, %{default: 0, min: 0})
    |> Executer.load(:acceleration_max_short, :double, %{default: 0, min: 0})
    |> Executer.call(&Nif.nif_sarext/10)
  end

  @dialyzer {:nowarn_function, sin: 1}
  @spec sin([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Sin

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SIN`
  """
  def sin(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_sin/1)
  end

  @dialyzer {:nowarn_function, sinh: 1}
  @spec sinh([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Sinh

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SINH`
  """
  def sinh(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_sinh/1)
  end

  @dialyzer {:nowarn_function, sma: 1}
  @spec sma([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Simple Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SMA`
  """
  def sma(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_sma/2)
  end

  @dialyzer {:nowarn_function, sqrt: 1}
  @spec sqrt([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Square Root

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SQRT`
  """
  def sqrt(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_sqrt/1)
  end

  @dialyzer {:nowarn_function, stddev: 1}
  @spec stddev([
          {:values, [number()]}
          | {:time_period, pos_integer()}
          | {:number_of_deviations, number()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Standard Deviation

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `number_of_deviations`: Number of deviations

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_STDDEV`
  """
  def stddev(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:number_of_deviations, :double)
    |> Executer.call(&Nif.nif_stddev/3)
  end

  @dialyzer {:nowarn_function, stoch: 1}
  @spec stoch([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:fast_k_period, pos_integer()}
          | {:slow_k_period, pos_integer()}
          | {:slow_k_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
          | {:slow_d_period, pos_integer()}
          | {:slow_d_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, slow_k :: [number() | :nan], slow_d :: [number() | :nan]} | {:error, term()}
  @doc """
  Stochastic

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `fast_k_period`: Time period for building the Fast-K line (between `1` and `100000`)
  - `slow_k_period`: Smoothing for making the Slow-K line. Usually set to 3 (between `1` and `100000`)
  - `slow_k_moving_average_type` (default `:sma`): Type of Moving Average for Slow-K
  - `slow_d_period`: Smoothing for making the Slow-D line (between `1` and `100000`)
  - `slow_d_moving_average_type` (default `:sma`): Type of Moving Average for Slow-K

  ---
  Outputs
  - `slow_k`
  - `slow_d`

  ---
  TA-LIB src `TA_STOCH`
  """
  def stoch(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:fast_k_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:slow_k_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:slow_k_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.load(:slow_d_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:slow_d_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_stoch/8)
  end

  @dialyzer {:nowarn_function, stochf: 1}
  @spec stochf([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:fast_k_period, pos_integer()}
          | {:fast_d_period, pos_integer()}
          | {:fast_d_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, fast_k :: [number() | :nan], fast_d :: [number() | :nan]} | {:error, term()}
  @doc """
  Stochastic Fast

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `fast_k_period`: Time period for building the Fast-K line (between `1` and `100000`)
  - `fast_d_period`: Smoothing for making the Fast-D line. Usually set to 3 (between `1` and `100000`)
  - `fast_d_moving_average_type` (default `:sma`): Type of Moving Average for Fast-D

  ---
  Outputs
  - `fast_k`
  - `fast_d`

  ---
  TA-LIB src `TA_STOCHF`
  """
  def stochf(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:fast_k_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:fast_d_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:fast_d_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_stochf/6)
  end

  @dialyzer {:nowarn_function, stochrsi: 1}
  @spec stochrsi([
          {:values, [number()]}
          | {:time_period, pos_integer()}
          | {:fast_k_period, pos_integer()}
          | {:fast_d_period, pos_integer()}
          | {:fast_d_moving_average_type,
             :sma | :ema | :wma | :dema | :tema | :trima | :kama | :mama | :t3}
        ]) :: {:ok, fast_k :: [number() | :nan], fast_d :: [number() | :nan]} | {:error, term()}
  @doc """
  Stochastic Relative Strength Index

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `fast_k_period`: Time period for building the Fast-K line (between `1` and `100000`)
  - `fast_d_period`: Smoothing for making the Fast-D line. Usually set to 3 (between `1` and `100000`)
  - `fast_d_moving_average_type` (default `:sma`): Type of Moving Average for Fast-D

  ---
  Outputs
  - `fast_k`
  - `fast_d`

  ---
  TA-LIB src `TA_STOCHRSI`
  """
  def stochrsi(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:fast_k_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:fast_d_period, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:fast_d_moving_average_type, :ma_type, %{default: :sma})
    |> Executer.call(&Nif.nif_stochrsi/5)
  end

  @dialyzer {:nowarn_function, sub: 1}
  @spec sub([{:values0, [number()]} | {:values1, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Arithmetic Substraction

  ---
  Inputs
  - `values0`
  - `values1`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SUB`
  """
  def sub(params) do
    params
    |> Executer.new()
    |> Executer.load(:values0, :double_array)
    |> Executer.load(:values1, :double_array)
    |> Executer.call(&Nif.nif_sub/2)
  end

  @dialyzer {:nowarn_function, sum: 1}
  @spec sum([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Summation

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_SUM`
  """
  def sum(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_sum/2)
  end

  @dialyzer {:nowarn_function, t3: 1}
  @spec t3([{:values, [number()]} | {:time_period, pos_integer()} | {:v_factor, number()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Triple Exponential Moving Average (T3)

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `v_factor`: Volume Factor (between `0` and `1`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_T3`
  """
  def t3(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:v_factor, :double, %{min: 0, max: 1})
    |> Executer.call(&Nif.nif_t3/3)
  end

  @dialyzer {:nowarn_function, tan: 1}
  @spec tan([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Tan

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TAN`
  """
  def tan(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_tan/1)
  end

  @dialyzer {:nowarn_function, tanh: 1}
  @spec tanh([{:values, [number()]}]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Vector Trigonometric Tanh

  ---
  Inputs
  - `values`

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TANH`
  """
  def tanh(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.call(&Nif.nif_tanh/1)
  end

  @dialyzer {:nowarn_function, tema: 1}
  @spec tema([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Triple Exponential Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TEMA`
  """
  def tema(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_tema/2)
  end

  @dialyzer {:nowarn_function, trange: 1}
  @spec trange([{:high, [number()]} | {:low, [number()]} | {:close, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  True Range

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TRANGE`
  """
  def trange(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_trange/3)
  end

  @dialyzer {:nowarn_function, trima: 1}
  @spec trima([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Triangular Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TRIMA`
  """
  def trima(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_trima/2)
  end

  @dialyzer {:nowarn_function, trix: 1}
  @spec trix([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  1-day Rate-Of-Change (ROC) of a Triple Smooth EMA

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TRIX`
  """
  def trix(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_trix/2)
  end

  @dialyzer {:nowarn_function, tsf: 1}
  @spec tsf([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Time Series Forecast

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TSF`
  """
  def tsf(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_tsf/2)
  end

  @dialyzer {:nowarn_function, typprice: 1}
  @spec typprice([{:high, [number()]} | {:low, [number()]} | {:close, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Typical Price

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_TYPPRICE`
  """
  def typprice(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_typprice/3)
  end

  @dialyzer {:nowarn_function, ultosc: 1}
  @spec ultosc([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period1, pos_integer()}
          | {:time_period2, pos_integer()}
          | {:time_period3, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Ultimate Oscillator

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period1`: Number of bars for 1st period (between `1` and `100000`)
  - `time_period2`: Number of bars for 2nd period (between `1` and `100000`)
  - `time_period3`: Number of bars for 3rd period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_ULTOSC`
  """
  def ultosc(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period1, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:time_period2, :integer, %{min: 1, max: 100_000})
    |> Executer.load(:time_period3, :integer, %{min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_ultosc/6)
  end

  @dialyzer {:nowarn_function, var: 1}
  @spec var([
          {:values, [number()]}
          | {:time_period, pos_integer()}
          | {:number_of_deviations, number()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Variance

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)
  - `number_of_deviations`: Number of deviations

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_VAR`
  """
  def var(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.load(:number_of_deviations, :double)
    |> Executer.call(&Nif.nif_var/3)
  end

  @dialyzer {:nowarn_function, wclprice: 1}
  @spec wclprice([{:high, [number()]} | {:low, [number()]} | {:close, [number()]}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Weighted Close Price

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_WCLPRICE`
  """
  def wclprice(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.call(&Nif.nif_wclprice/3)
  end

  @dialyzer {:nowarn_function, willr: 1}
  @spec willr([
          {:high, [number()]}
          | {:low, [number()]}
          | {:close, [number()]}
          | {:time_period, pos_integer()}
        ]) :: {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Williams' %R

  ---
  Inputs
  - `high`: High Price List
  - `low`: Low Price List
  - `close`: Close Price List
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_WILLR`
  """
  def willr(params) do
    params
    |> Executer.new()
    |> Executer.load(:high, :double_array)
    |> Executer.load(:low, :double_array)
    |> Executer.load(:close, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_willr/4)
  end

  @dialyzer {:nowarn_function, wma: 1}
  @spec wma([{:values, [number()]} | {:time_period, pos_integer()}]) ::
          {:ok, result :: [number() | :nan]} | {:error, term()}
  @doc """
  Weighted Moving Average

  ---
  Inputs
  - `values`
  - `time_period` (default `5`): Number of period (between `1` and `100000`)

  ---
  Outputs
  - `result`

  ---
  TA-LIB src `TA_WMA`
  """
  def wma(params) do
    params
    |> Executer.new()
    |> Executer.load(:values, :double_array)
    |> Executer.load(:time_period, :integer, %{default: 5, min: 1, max: 100_000})
    |> Executer.call(&Nif.nif_wma/2)
  end
end