ta_lib_ffi 0.2.0 → 0.3.0

data/lib/ta_lib_ffi.rb

@@ -4,11 +4,25 @@ require "fiddle"
 require "fiddle/import"
 
 # Ruby FFI wrapper for TA-Lib (Technical Analysis Library)
+#
+# This module provides a Ruby interface to the TA-Lib technical analysis library
+# using FFI (Foreign Function Interface). It allows you to perform various
+# technical analysis calculations on financial market data.
+#
+# @example Basic usage
+#   require 'ta_lib_ffi'
+#
+#   # Calculate Simple Moving Average
+#   prices = [10.0, 11.0, 12.0, 11.0, 10.0]
+#   result = TALibFFI.sma(prices, time_period: 3)
+#
+# @see https://ta-lib.org/ TA-Lib Official Website
 module TALibFFI
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 
   if defined?(Zeitwerk)
-    # Custom inflector for handling special case module names like TALibFFI
+    # https://github.com/fxn/zeitwerk?tab=readme-ov-file#custom-inflector
+    # @!visibility private
     class Inflector < Zeitwerk::GemInflector
       def camelize(basename, _abspath)
         case basename
@@ -210,6 +224,11 @@ module TALibFFI
 
   module_function
 
+  # Extracts flags from a bitmask value based on the flag type
+  #
+  # @param value [Integer] The bitmask value to extract flags from
+  # @param type [Symbol] The type of flags to extract (:TA_InputFlags, :TA_OptInputFlags, or :TA_OutputFlags)
+  # @return [Array<Symbol>] Array of flag names that are set in the bitmask
   def extract_flags(value, type)
     flags_set = []
     TA_FLAGS[type].each do |k, v|
@@ -218,6 +237,9 @@ module TALibFFI
     flags_set
   end
 
+  # Returns a list of all available function groups in TA-Lib
+  #
+  # @return [Array<String>] Array of group names
   def group_table
     string_table_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
     ret_code = TA_GroupTableAlloc(string_table_ptr.ref)
@@ -230,6 +252,10 @@ module TALibFFI
     group_names
   end
 
+  # Returns a list of all functions in a specific group
+  #
+  # @param group [String] The name of the group to get functions for
+  # @return [Array<String>] Array of function names in the group
   def function_table(group)
     string_table_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
     ret_code = TA_FuncTableAlloc(group, string_table_ptr.ref)
@@ -243,6 +269,10 @@ module TALibFFI
     func_names
   end
 
+  # Gets detailed information about a specific TA-Lib function
+  #
+  # @param name [String] The name of the function to get information for
+  # @return [Fiddle::CStructEntity] Struct containing function information
   def function_info(name)
     handle_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
     ret_code = TA_GetFuncHandle(name, handle_ptr.ref)
@@ -255,6 +285,10 @@ module TALibFFI
     TA_FuncInfo.new(info_ptr)
   end
 
+  # Iterates over all available TA-Lib functions
+  #
+  # @yield [func_info] Yields function information for each function
+  # @yieldparam func_info [Fiddle::CStructEntity] Function information struct
   def each_function(&block)
     callback = Fiddle::Closure::BlockCaller.new(
       Fiddle::TYPE_VOID,
@@ -268,9 +302,10 @@ module TALibFFI
     check_ta_return_code(ret_code)
   end
 
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/AbcSize
-  def print_function_info(func_info)
+  # Prints detailed information about a TA-Lib function
+  #
+  # @param func_info [Fiddle::CStructEntity] Function information struct to print
+  def print_function_info(func_info) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
     puts "Function Name: #{func_info["name"]}"
     puts "Function Group: #{func_info["group"]}"
     puts "Function Hint: #{func_info["hint"]}"
@@ -320,11 +355,14 @@ module TALibFFI
       puts "    Flags: #{extract_flags(param_info["flags"], :TA_OutputFlags)}"
     end
   end
-  # rubocop:enable Metrics/MethodLength
-  # rubocop:enable Metrics/AbcSize
 
-  # rubocop:disable Metrics/MethodLength
-  def call_func(func_name, args)
+  # Calls a TA-Lib function with the given arguments
+  #
+  # @param func_name [String] The name of the function to call
+  # @param args [Array] Array of input arrays and optional parameters
+  # @return [Array, Hash] Function results (single array or hash of named outputs)
+  # @raise [TALibError] If there is an error in function execution
+  def call_func(func_name, args) # rubocop:disable Metrics/MethodLength
     options = args.last.is_a?(Hash) ? args.pop : {}
     input_arrays = args
 
@@ -337,13 +375,16 @@ module TALibFFI
       setup_input_parameters(params_ptr, input_arrays, func_name)
       setup_optional_parameters(params_ptr, options, func_name)
       _lookback = calculate_lookback(params_ptr)
-      calculate_results(params_ptr, input_arrays.first.length, func_name)
+      calculate_results(params_ptr, input_arrays, func_name)
     ensure
       TA_ParamHolderFree(params_ptr)
     end
   end
-  # rubocop:enable Metrics/MethodLength
 
+  # Calculates the lookback period for a function with given parameters
+  #
+  # @param params_ptr [Fiddle::Pointer] Pointer to parameter holder
+  # @return [Integer] The lookback period
   def calculate_lookback(params_ptr)
     lookback_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
     ret_code = TA_GetLookback(params_ptr, lookback_ptr)
@@ -351,9 +392,11 @@ module TALibFFI
     lookback_ptr[0, Fiddle::SIZEOF_INT].unpack1("l")
   end
 
-  # rubocop:disable Metrics/CyclomaticComplexity
-  # rubocop:disable Metrics/PerceivedComplexity
-  def validate_inputs!(arrays)
+  # Validates input arrays for TA-Lib functions
+  #
+  # @param arrays [Array<Array>] Arrays to validate
+  # @raise [TALibError] If any array is invalid
+  def validate_inputs!(arrays) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
     raise TALibError, "Input arrays cannot be empty" if arrays.empty?
 
     arrays.each do |arr|
@@ -367,9 +410,11 @@ module TALibFFI
       raise TALibError, "Input arrays must contain only numbers" unless arr.flatten.all? { |x| x.is_a?(Numeric) }
     end
   end
-  # rubocop:enable Metrics/CyclomaticComplexity
-  # rubocop:enable Metrics/PerceivedComplexity
 
+  # Gets a function handle for a given function name
+  #
+  # @param func_name [String] The name of the function
+  # @return [Fiddle::Pointer] Pointer to function handle
   def get_function_handle(func_name)
     handle_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
     ret_code = TA_GetFuncHandle(func_name, handle_ptr.ref)
@@ -377,6 +422,10 @@ module TALibFFI
     handle_ptr
   end
 
+  # Creates a parameter holder for a function
+  #
+  # @param handle_ptr [Fiddle::Pointer] Function handle pointer
+  # @return [Fiddle::Pointer] Pointer to parameter holder
   def create_parameter_holder(handle_ptr)
     params_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
     ret_code = TA_ParamHolderAlloc(handle_ptr, params_ptr.ref)
@@ -384,6 +433,11 @@ module TALibFFI
     params_ptr
   end
 
+  # Sets up input parameters for a function call
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param input_arrays [Array<Array>] Input data arrays
+  # @param func_name [String] Function name
   def setup_input_parameters(params_ptr, input_arrays, func_name)
     func_info = function_info_map[func_name]
     input_arrays.each_with_index do |array, index|
@@ -393,6 +447,13 @@ module TALibFFI
     end
   end
 
+  # Sets a single input parameter
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param index [Integer] Parameter index
+  # @param array [Array] Input data array
+  # @param input_info [Hash] Input parameter information
+  # @return [Integer] TA-Lib return code
   def set_input_parameter(params_ptr, index, array, input_info)
     case input_info["type"]
     when TA_PARAM_TYPE[:TA_Input_Real]
@@ -406,6 +467,10 @@ module TALibFFI
     end
   end
 
+  # Prepares a double array for TA-Lib input
+  #
+  # @param array [Array<Numeric>] Array of numbers to prepare
+  # @return [Fiddle::Pointer] Pointer to prepared array
   def prepare_double_array(array)
     array_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * array.length)
     array.each_with_index do |value, i|
@@ -414,6 +479,10 @@ module TALibFFI
     array_ptr
   end
 
+  # Prepares an integer array for TA-Lib input
+  #
+  # @param array [Array<Numeric>] Array of numbers to prepare
+  # @return [Fiddle::Pointer] Pointer to prepared array
   def prepare_integer_array(array)
     array_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT * array.length)
     array.each_with_index do |value, i|
@@ -422,6 +491,11 @@ module TALibFFI
     array_ptr
   end
 
+  # Sets up optional parameters for a function call
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param options [Hash] Optional parameters
+  # @param func_name [String] Function name
   def setup_optional_parameters(params_ptr, options, func_name)
     func_info = function_info_map[func_name]
     func_info[:opt_inputs]&.each_with_index do |opt_input, index|
@@ -430,6 +504,12 @@ module TALibFFI
     end
   end
 
+  # Sets a single optional parameter
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param index [Integer] Parameter index
+  # @param value [Numeric] Parameter value
+  # @param type [Integer] Parameter type
   def set_optional_parameter(params_ptr, index, value, type)
     case type
     when TA_PARAM_TYPE[:TA_OptInput_RealRange], TA_PARAM_TYPE[:TA_OptInput_RealList]
@@ -440,8 +520,20 @@ module TALibFFI
     check_ta_return_code(ret_code)
   end
 
-  # rubocop:disable Metrics/MethodLength
-  def calculate_results(params_ptr, input_size, func_name)
+  # Calculates function results
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param input_arrays [Array] Input data
+  # @param func_name [String] Function name
+  # @return [Array, Hash] Function results
+  def calculate_results(params_ptr, input_arrays, func_name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    func_info = function_info_map[func_name]
+    input_size = if func_info[:inputs].first["type"] == TA_PARAM_TYPE[:TA_Input_Price]
+                   input_arrays[0][0].length
+                 else
+                   input_arrays[0].length
+                 end
+
     out_begin = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
     out_size = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
     output_arrays = setup_output_buffers(params_ptr, input_size, func_name)
@@ -458,11 +550,14 @@ module TALibFFI
       output_arrays.each(&:free)
     end
   end
-  # rubocop:enable Metrics/MethodLength
 
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/AbcSize
-  def setup_output_buffers(params_ptr, size, func_name)
+  # Sets up output buffers for function results
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param size [Integer] Size of output buffer
+  # @param func_name [String] Function name
+  # @return [Array<Fiddle::Pointer>] Array of output buffer pointers
+  def setup_output_buffers(params_ptr, size, func_name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
     func_info = function_info_map[func_name]
     output_ptrs = []
 
@@ -488,12 +583,14 @@ module TALibFFI
 
     output_ptrs
   end
-  # rubocop:enable Metrics/MethodLength
-  # rubocop:enable Metrics/AbcSize
 
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/AbcSize
-  def format_output_results(output_ptrs, size, func_name)
+  # Formats output results from TA-Lib function
+  #
+  # @param output_ptrs [Array<Fiddle::Pointer>] Array of output buffer pointers
+  # @param size [Integer] Size of output data
+  # @param func_name [String] Function name
+  # @return [Array, Hash] Formatted results
+  def format_output_results(output_ptrs, size, func_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
     func_info = function_info_map[func_name]
     results = output_ptrs.zip(func_info[:outputs]).map do |ptr, output|
       case output["type"]
@@ -511,17 +608,24 @@ module TALibFFI
     end
     output_names.zip(results).to_h
   end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/MethodLength
 
+  # Gets XML description of all TA-Lib functions
+  #
+  # @return [String] XML function descriptions
   def function_description_xml
     TA_FunctionDescriptionXML().to_s
   end
 
+  # Gets or builds the function information map
+  #
+  # @return [Hash] Map of function information
   def function_info_map
     @function_info_map ||= build_function_info_map
   end
 
+  # Builds a map of function information for all functions
+  #
+  # @return [Hash] Map of function information
   def build_function_info_map
     info_map = {}
     each_function do |func_info|
@@ -535,6 +639,10 @@ module TALibFFI
     info_map
   end
 
+  # Collects input parameter information for a function
+  #
+  # @param func_info [Fiddle::CStructEntity] Function information
+  # @return [Array<Fiddle::CStructEntity>] Array of input parameter information
   def collect_input_info(func_info)
     func_info["nbInput"].times.map do |i|
       param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
@@ -543,6 +651,10 @@ module TALibFFI
     end
   end
 
+  # Collects optional input parameter information for a function
+  #
+  # @param func_info [Fiddle::CStructEntity] Function information
+  # @return [Array<Fiddle::CStructEntity>] Array of optional input parameter information
   def collect_opt_input_info(func_info)
     func_info["nbOptInput"].times.map do |i|
       param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
@@ -551,6 +663,10 @@ module TALibFFI
     end
   end
 
+  # Collects output parameter information for a function
+  #
+  # @param func_info [Fiddle::CStructEntity] Function information
+  # @return [Array<Fiddle::CStructEntity>] Array of output parameter information
   def collect_output_info(func_info)
     func_info["nbOutput"].times.map do |i|
       param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
@@ -559,14 +675,22 @@ module TALibFFI
     end
   end
 
+  # Generates Ruby methods for all TA-Lib functions
+  #
+  # This method iterates through all available TA-Lib functions and creates
+  # corresponding Ruby methods with proper documentation.
   def generate_ta_functions
     each_function do |func_info|
       define_ta_function(func_info["name"].to_s.downcase, func_info["name"].to_s)
     end
   end
 
+  # Normalizes parameter names to Ruby style
+  #
+  # @param name [String] Parameter name to normalize
+  # @return [String] Normalized parameter name
   def normalize_parameter_name(name)
-    name.sub(/^(optIn|outReal|outInteger|out)/, "")
+    name.sub(/^(optIn|outReal|outInteger|out|in)/, "")
         .gsub(/::/, "/")
         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
@@ -574,10 +698,11 @@ module TALibFFI
         .downcase
   end
 
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/CyclomaticComplexity
-  def check_ta_return_code(code)
+  # Checks TA-Lib return codes and raises appropriate errors
+  #
+  # @param code [Integer] TA-Lib return code
+  # @raise [TALibError] If the return code indicates an error
+  def check_ta_return_code(code) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
     return if code == TA_SUCCESS
 
     error_message = case code
@@ -623,10 +748,8 @@ module TALibFFI
 
     raise TALibError, error_message
   end
-  # rubocop:enable Metrics/CyclomaticComplexity
-  # rubocop:enable Metrics/MethodLength
-  # rubocop:enable Metrics/AbcSize
 
+  # Initializes the TA-Lib library
   def initialize_ta_lib
     return if @initialized
 
@@ -636,21 +759,28 @@ module TALibFFI
     @initialized = true
   end
 
+  # Defines a TA-Lib function as a Ruby method with documentation
+  #
+  # @param method_name [String] Name of the Ruby method to define
+  # @param func_name [String] Name of the TA-Lib function
   def define_ta_function(method_name, func_name)
     define_singleton_method(method_name) do |*args|
       call_func(func_name, args)
     end
   end
 
+  # Sets up price inputs for functions that take price data
+  #
+  # @param params_ptr [Fiddle::Pointer] Parameter holder pointer
+  # @param index [Integer] Parameter index
+  # @param price_data [Array] Price data array
+  # @param flags [Integer] Input flags
   def setup_price_inputs(params_ptr, index, price_data, flags)
     required_flags = extract_flags(flags, :TA_InputFlags)
-    data_pointers = Array.new(6) { nil }
-    TA_FLAGS[:TA_InputFlags].keys[0..5].each_with_index do |flag, i|
-      data_pointers[i] = if required_flags.include?(flag)
-                           prepare_double_array(price_data[required_flags.index(flag)])
-                         else
-                           Fiddle::Pointer.malloc(0)
-                         end
+    data_pointers = Array.new(6) { Fiddle::Pointer.malloc(0) }
+    required_flags.each_with_index do |flag, i|
+      flag_index = TA_FLAGS[:TA_InputFlags].keys.index(flag)
+      data_pointers[flag_index] = prepare_double_array(price_data[i]) if required_flags.include?(flag)
     end
 
     TA_SetInputParamPricePtr(params_ptr, index, *data_pointers)
@@ -658,4 +788,1295 @@ module TALibFFI
 
   initialize_ta_lib
   generate_ta_functions
+
+  # Placeholder for generated TA-Lib function documentation.
+  # Generated using YARD.
+  # Run: rake yard
+  class << self
+    ### GENERATED DOCUMENTATION START ###
+    # @!method accbands(price_hlc, time_period: 20.0)
+    # Acceleration Bands
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 20.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :upper_band  Output values
+    # @option result [Array<Float>] :middle_band  Output values
+    # @option result [Array<Float>] :lower_band  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method acos(real)
+    # Vector Trigonometric ACos
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ad(price_hlcv)
+    # Chaikin A/D Line
+    #
+    # @param price_hlcv [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close, volume
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method add(real0, real1)
+    # Vector Arithmetic Add
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method adosc(price_hlcv, fast_period: 3.0, slow_period: 10.0)
+    # Chaikin A/D Oscillator
+    #
+    # @param price_hlcv [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close, volume
+    # @param fast_period [Integer]  Number of period for the fast MA (default: 3.0)
+    # @param slow_period [Integer]  Number of period for the slow MA (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method adx(price_hlc, time_period: 14.0)
+    # Average Directional Movement Index
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method adxr(price_hlc, time_period: 14.0)
+    # Average Directional Movement Index Rating
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method apo(real, fast_period: 12.0, slow_period: 26.0, ma_type: 0.0)
+    # Absolute Price Oscillator
+    #
+    # @param real [Array<Float>]  Input values
+    # @param fast_period [Integer]  Number of period for the fast MA (default: 12.0)
+    # @param slow_period [Integer]  Number of period for the slow MA (default: 26.0)
+    # @param ma_type [Integer]  Type of Moving Average (default: 0.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method aroon(price_hl, time_period: 14.0)
+    # Aroon
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :aroon_down  Output values
+    # @option result [Array<Float>] :aroon_up  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method aroonosc(price_hl, time_period: 14.0)
+    # Aroon Oscillator
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method asin(real)
+    # Vector Trigonometric ASin
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method atan(real)
+    # Vector Trigonometric ATan
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method atr(price_hlc, time_period: 14.0)
+    # Average True Range
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method avgprice(price_ohlc)
+    # Average Price
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method avgdev(real, time_period: 14.0)
+    # Average Deviation
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method bbands(real, time_period: 5.0, nb_dev_up: 2.0, nb_dev_dn: 2.0, ma_type: 0.0)
+    # Bollinger Bands
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 5.0)
+    # @param nb_dev_up [Float]  Deviation multiplier for upper band (default: 2.0)
+    # @param nb_dev_dn [Float]  Deviation multiplier for lower band (default: 2.0)
+    # @param ma_type [Integer]  Type of Moving Average (default: 0.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :upper_band  Output values
+    # @option result [Array<Float>] :middle_band  Output values
+    # @option result [Array<Float>] :lower_band  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method beta(real0, real1, time_period: 5.0)
+    # Beta
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 5.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method bop(price_ohlc)
+    # Balance Of Power
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cci(price_hlc, time_period: 14.0)
+    # Commodity Channel Index
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl2crows(price_ohlc)
+    # Two Crows
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3blackcrows(price_ohlc)
+    # Three Black Crows
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3inside(price_ohlc)
+    # Three Inside Up/Down
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3linestrike(price_ohlc)
+    # Three-Line Strike
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3outside(price_ohlc)
+    # Three Outside Up/Down
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3starsinsouth(price_ohlc)
+    # Three Stars In The South
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdl3whitesoldiers(price_ohlc)
+    # Three Advancing White Soldiers
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlabandonedbaby(price_ohlc, penetration: 0.3)
+    # Abandoned Baby
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.3)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdladvanceblock(price_ohlc)
+    # Advance Block
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlbelthold(price_ohlc)
+    # Belt-hold
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlbreakaway(price_ohlc)
+    # Breakaway
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlclosingmarubozu(price_ohlc)
+    # Closing Marubozu
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlconcealbabyswall(price_ohlc)
+    # Concealing Baby Swallow
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlcounterattack(price_ohlc)
+    # Counterattack
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdldarkcloudcover(price_ohlc, penetration: 0.5)
+    # Dark Cloud Cover
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.5)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdldoji(price_ohlc)
+    # Doji
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdldojistar(price_ohlc)
+    # Doji Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdldragonflydoji(price_ohlc)
+    # Dragonfly Doji
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlengulfing(price_ohlc)
+    # Engulfing Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdleveningdojistar(price_ohlc, penetration: 0.3)
+    # Evening Doji Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.3)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdleveningstar(price_ohlc, penetration: 0.3)
+    # Evening Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.3)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlgapsidesidewhite(price_ohlc)
+    # Up/Down-gap side-by-side white lines
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlgravestonedoji(price_ohlc)
+    # Gravestone Doji
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhammer(price_ohlc)
+    # Hammer
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhangingman(price_ohlc)
+    # Hanging Man
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlharami(price_ohlc)
+    # Harami Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlharamicross(price_ohlc)
+    # Harami Cross Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhighwave(price_ohlc)
+    # High-Wave Candle
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhikkake(price_ohlc)
+    # Hikkake Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhikkakemod(price_ohlc)
+    # Modified Hikkake Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlhomingpigeon(price_ohlc)
+    # Homing Pigeon
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlidentical3crows(price_ohlc)
+    # Identical Three Crows
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlinneck(price_ohlc)
+    # In-Neck Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlinvertedhammer(price_ohlc)
+    # Inverted Hammer
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlkicking(price_ohlc)
+    # Kicking
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlkickingbylength(price_ohlc)
+    # Kicking - bull/bear determined by the longer marubozu
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlladderbottom(price_ohlc)
+    # Ladder Bottom
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdllongleggeddoji(price_ohlc)
+    # Long Legged Doji
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdllongline(price_ohlc)
+    # Long Line Candle
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlmarubozu(price_ohlc)
+    # Marubozu
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlmatchinglow(price_ohlc)
+    # Matching Low
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlmathold(price_ohlc, penetration: 0.5)
+    # Mat Hold
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.5)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlmorningdojistar(price_ohlc, penetration: 0.3)
+    # Morning Doji Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.3)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlmorningstar(price_ohlc, penetration: 0.3)
+    # Morning Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @param penetration [Float]  Percentage of penetration of a candle within another candle (default: 0.3)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlonneck(price_ohlc)
+    # On-Neck Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlpiercing(price_ohlc)
+    # Piercing Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlrickshawman(price_ohlc)
+    # Rickshaw Man
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlrisefall3methods(price_ohlc)
+    # Rising/Falling Three Methods
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlseparatinglines(price_ohlc)
+    # Separating Lines
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlshootingstar(price_ohlc)
+    # Shooting Star
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlshortline(price_ohlc)
+    # Short Line Candle
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlspinningtop(price_ohlc)
+    # Spinning Top
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlstalledpattern(price_ohlc)
+    # Stalled Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlsticksandwich(price_ohlc)
+    # Stick Sandwich
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdltakuri(price_ohlc)
+    # Takuri (Dragonfly Doji with very long lower shadow)
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdltasukigap(price_ohlc)
+    # Tasuki Gap
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlthrusting(price_ohlc)
+    # Thrusting Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdltristar(price_ohlc)
+    # Tristar Pattern
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlunique3river(price_ohlc)
+    # Unique 3 River
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlupsidegap2crows(price_ohlc)
+    # Upside Gap Two Crows
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cdlxsidegap3methods(price_ohlc)
+    # Upside/Downside Gap Three Methods
+    #
+    # @param price_ohlc [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: open, high, low, close
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ceil(real)
+    # Vector Ceil
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cmo(real, time_period: 14.0)
+    # Chande Momentum Oscillator
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method correl(real0, real1, time_period: 30.0)
+    # Pearson's Correlation Coefficient (r)
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cos(real)
+    # Vector Trigonometric Cos
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method cosh(real)
+    # Vector Trigonometric Cosh
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method dema(real, time_period: 30.0)
+    # Double Exponential Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method div(real0, real1)
+    # Vector Arithmetic Div
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method dx(price_hlc, time_period: 14.0)
+    # Directional Movement Index
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ema(real, time_period: 30.0)
+    # Exponential Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method exp(real)
+    # Vector Arithmetic Exp
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method floor(real)
+    # Vector Floor
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_dcperiod(real)
+    # Hilbert Transform - Dominant Cycle Period
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_dcphase(real)
+    # Hilbert Transform - Dominant Cycle Phase
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_phasor(real)
+    # Hilbert Transform - Phasor Components
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :in_phase  Output values
+    # @option result [Array<Float>] :quadrature  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_sine(real)
+    # Hilbert Transform - SineWave
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :sine  Output values
+    # @option result [Array<Float>] :lead_sine  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_trendline(real)
+    # Hilbert Transform - Instantaneous Trendline
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ht_trendmode(real)
+    # Hilbert Transform - Trend vs Cycle Mode
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method imi(price_oc, time_period: 14.0)
+    # Intraday Momentum Index
+    #
+    # @param price_oc [Array(Array<Float>, Array<Float>)]  Required price arrays: open, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method kama(real, time_period: 30.0)
+    # Kaufman Adaptive Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method linearreg(real, time_period: 14.0)
+    # Linear Regression
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method linearreg_angle(real, time_period: 14.0)
+    # Linear Regression Angle
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method linearreg_intercept(real, time_period: 14.0)
+    # Linear Regression Intercept
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method linearreg_slope(real, time_period: 14.0)
+    # Linear Regression Slope
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ln(real)
+    # Vector Log Natural
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method log10(real)
+    # Vector Log10
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ma(real, time_period: 30.0, ma_type: 0.0)
+    # Moving average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @param ma_type [Integer]  Type of Moving Average (default: 0.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method macd(real, fast_period: 12.0, slow_period: 26.0, signal_period: 9.0)
+    # Moving Average Convergence/Divergence
+    #
+    # @param real [Array<Float>]  Input values
+    # @param fast_period [Integer]  Number of period for the fast MA (default: 12.0)
+    # @param slow_period [Integer]  Number of period for the slow MA (default: 26.0)
+    # @param signal_period [Integer]  Smoothing for the signal line (nb of period) (default: 9.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :macd  Output values
+    # @option result [Array<Float>] :macd_signal  Output values
+    # @option result [Array<Float>] :macd_hist  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method macdext(real, fast_period: 12.0, fast_ma_type: 0.0, slow_period: 26.0, slow_ma_type: 0.0, signal_period: 9.0, signal_ma_type: 0.0)
+    # MACD with controllable MA type
+    #
+    # @param real [Array<Float>]  Input values
+    # @param fast_period [Integer]  Number of period for the fast MA (default: 12.0)
+    # @param fast_ma_type [Integer]  Type of Moving Average for fast MA (default: 0.0)
+    # @param slow_period [Integer]  Number of period for the slow MA (default: 26.0)
+    # @param slow_ma_type [Integer]  Type of Moving Average for slow MA (default: 0.0)
+    # @param signal_period [Integer]  Smoothing for the signal line (nb of period) (default: 9.0)
+    # @param signal_ma_type [Integer]  Type of Moving Average for signal line (default: 0.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :macd  Output values
+    # @option result [Array<Float>] :macd_signal  Output values
+    # @option result [Array<Float>] :macd_hist  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method macdfix(real, signal_period: 9.0)
+    # Moving Average Convergence/Divergence Fix 12/26
+    #
+    # @param real [Array<Float>]  Input values
+    # @param signal_period [Integer]  Smoothing for the signal line (nb of period) (default: 9.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :macd  Output values
+    # @option result [Array<Float>] :macd_signal  Output values
+    # @option result [Array<Float>] :macd_hist  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method mama(real, fast_limit: 0.5, slow_limit: 0.05)
+    # MESA Adaptive Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param fast_limit [Float]  Upper limit use in the adaptive algorithm (default: 0.5)
+    # @param slow_limit [Float]  Lower limit use in the adaptive algorithm (default: 0.05)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :mama  Output values
+    # @option result [Array<Float>] :fama  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method mavp(real, periods, min_period: 2.0, max_period: 30.0, ma_type: 0.0)
+    # Moving average with variable period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param periods [Array<Float>]  Input values
+    # @param min_period [Integer]  Value less than minimum will be changed to Minimum period (default: 2.0)
+    # @param max_period [Integer]  Value higher than maximum will be changed to Maximum period (default: 30.0)
+    # @param ma_type [Integer]  Type of Moving Average (default: 0.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method max(real, time_period: 30.0)
+    # Highest value over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method maxindex(real, time_period: 30.0)
+    # Index of highest value over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method medprice(price_hl)
+    # Median Price
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method mfi(price_hlcv, time_period: 14.0)
+    # Money Flow Index
+    #
+    # @param price_hlcv [Array(Array<Float>, Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close, volume
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method midpoint(real, time_period: 14.0)
+    # MidPoint over period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method midprice(price_hl, time_period: 14.0)
+    # Midpoint Price over period
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method min(real, time_period: 30.0)
+    # Lowest value over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method minindex(real, time_period: 30.0)
+    # Index of lowest value over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Integer>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method minmax(real, time_period: 30.0)
+    # Lowest and highest values over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :min  Output values
+    # @option result [Array<Float>] :max  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method minmaxindex(real, time_period: 30.0)
+    # Indexes of lowest and highest values over a specified period
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Integer>] :min_idx  Output values
+    # @option result [Array<Integer>] :max_idx  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method minus_di(price_hlc, time_period: 14.0)
+    # Minus Directional Indicator
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method minus_dm(price_hl, time_period: 14.0)
+    # Minus Directional Movement
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method mom(real, time_period: 10.0)
+    # Momentum
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method mult(real0, real1)
+    # Vector Arithmetic Mult
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method natr(price_hlc, time_period: 14.0)
+    # Normalized Average True Range
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method obv(real, price_v)
+    # On Balance Volume
+    #
+    # @param real [Array<Float>]  Input values
+    # @param price_v [Array(Array<Float>)]  Required price arrays: volume
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method plus_di(price_hlc, time_period: 14.0)
+    # Plus Directional Indicator
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method plus_dm(price_hl, time_period: 14.0)
+    # Plus Directional Movement
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ppo(real, fast_period: 12.0, slow_period: 26.0, ma_type: 0.0)
+    # Percentage Price Oscillator
+    #
+    # @param real [Array<Float>]  Input values
+    # @param fast_period [Integer]  Number of period for the fast MA (default: 12.0)
+    # @param slow_period [Integer]  Number of period for the slow MA (default: 26.0)
+    # @param ma_type [Integer]  Type of Moving Average (default: 0.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method roc(real, time_period: 10.0)
+    # Rate of change : ((price/prevPrice)-1)*100
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method rocp(real, time_period: 10.0)
+    # Rate of change Percentage: (price-prevPrice)/prevPrice
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method rocr(real, time_period: 10.0)
+    # Rate of change ratio: (price/prevPrice)
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method rocr100(real, time_period: 10.0)
+    # Rate of change ratio 100 scale: (price/prevPrice)*100
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 10.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method rsi(real, time_period: 14.0)
+    # Relative Strength Index
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sar(price_hl, acceleration: 0.02, maximum: 0.2)
+    # Parabolic SAR
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param acceleration [Float]  Acceleration Factor used up to the Maximum value (default: 0.02)
+    # @param maximum [Float]  Acceleration Factor Maximum value (default: 0.2)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sarext(price_hl, start_value: 0.0, offset_on_reverse: 0.0, acceleration_init_long: 0.02, acceleration_long: 0.02, acceleration_max_long: 0.2, acceleration_init_short: 0.02, acceleration_short: 0.02, acceleration_max_short: 0.2)
+    # Parabolic SAR - Extended
+    #
+    # @param price_hl [Array(Array<Float>, Array<Float>)]  Required price arrays: high, low
+    # @param start_value [Float]  Start value and direction. 0 for Auto, >0 for Long, <0 for Short (default: 0.0)
+    # @param offset_on_reverse [Float]  Percent offset added/removed to initial stop on short/long reversal (default: 0.0)
+    # @param acceleration_init_long [Float]  Acceleration Factor initial value for the Long direction (default: 0.02)
+    # @param acceleration_long [Float]  Acceleration Factor for the Long direction (default: 0.02)
+    # @param acceleration_max_long [Float]  Acceleration Factor maximum value for the Long direction (default: 0.2)
+    # @param acceleration_init_short [Float]  Acceleration Factor initial value for the Short direction (default: 0.02)
+    # @param acceleration_short [Float]  Acceleration Factor for the Short direction (default: 0.02)
+    # @param acceleration_max_short [Float]  Acceleration Factor maximum value for the Short direction (default: 0.2)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sin(real)
+    # Vector Trigonometric Sin
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sinh(real)
+    # Vector Trigonometric Sinh
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sma(real, time_period: 30.0)
+    # Simple Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sqrt(real)
+    # Vector Square Root
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method stddev(real, time_period: 5.0, nb_dev: 1.0)
+    # Standard Deviation
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 5.0)
+    # @param nb_dev [Float]  Nb of deviations (default: 1.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method stoch(price_hlc, fast_k_period: 5.0, slow_k_period: 3.0, slow_k_ma_type: 0.0, slow_d_period: 3.0, slow_d_ma_type: 0.0)
+    # Stochastic
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param fast_k_period [Integer]  Time period for building the Fast-K line (default: 5.0)
+    # @param slow_k_period [Integer]  Smoothing for making the Slow-K line. Usually set to 3 (default: 3.0)
+    # @param slow_k_ma_type [Integer]  Type of Moving Average for Slow-K (default: 0.0)
+    # @param slow_d_period [Integer]  Smoothing for making the Slow-D line (default: 3.0)
+    # @param slow_d_ma_type [Integer]  Type of Moving Average for Slow-D (default: 0.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :slow_k  Output values
+    # @option result [Array<Float>] :slow_d  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method stochf(price_hlc, fast_k_period: 5.0, fast_d_period: 3.0, fast_d_ma_type: 0.0)
+    # Stochastic Fast
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param fast_k_period [Integer]  Time period for building the Fast-K line (default: 5.0)
+    # @param fast_d_period [Integer]  Smoothing for making the Fast-D line. Usually set to 3 (default: 3.0)
+    # @param fast_d_ma_type [Integer]  Type of Moving Average for Fast-D (default: 0.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :fast_k  Output values
+    # @option result [Array<Float>] :fast_d  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method stochrsi(real, time_period: 14.0, fast_k_period: 5.0, fast_d_period: 3.0, fast_d_ma_type: 0.0)
+    # Stochastic Relative Strength Index
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @param fast_k_period [Integer]  Time period for building the Fast-K line (default: 5.0)
+    # @param fast_d_period [Integer]  Smoothing for making the Fast-D line. Usually set to 3 (default: 3.0)
+    # @param fast_d_ma_type [Integer]  Type of Moving Average for Fast-D (default: 0.0)
+    # @return [Hash]  Hash containing the following arrays:
+    # @option result [Array<Float>] :fast_k  Output values
+    # @option result [Array<Float>] :fast_d  Output values
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sub(real0, real1)
+    # Vector Arithmetic Subtraction
+    #
+    # @param real0 [Array<Float>]  Input values
+    # @param real1 [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method sum(real, time_period: 30.0)
+    # Summation
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method t3(real, time_period: 5.0, v_factor: 0.7)
+    # Triple Exponential Moving Average (T3)
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 5.0)
+    # @param v_factor [Float]  Volume Factor (default: 0.7)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method tan(real)
+    # Vector Trigonometric Tan
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method tanh(real)
+    # Vector Trigonometric Tanh
+    #
+    # @param real [Array<Float>]  Input values
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method tema(real, time_period: 30.0)
+    # Triple Exponential Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method trange(price_hlc)
+    # True Range
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method trima(real, time_period: 30.0)
+    # Triangular Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method trix(real, time_period: 30.0)
+    # 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method tsf(real, time_period: 14.0)
+    # Time Series Forecast
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method typprice(price_hlc)
+    # Typical Price
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method ultosc(price_hlc, time_period1: 7.0, time_period2: 14.0, time_period3: 28.0)
+    # Ultimate Oscillator
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period1 [Integer]  Number of bars for 1st period. (default: 7.0)
+    # @param time_period2 [Integer]  Number of bars fro 2nd period (default: 14.0)
+    # @param time_period3 [Integer]  Number of bars for 3rd period (default: 28.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method var(real, time_period: 5.0, nb_dev: 1.0)
+    # Variance
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 5.0)
+    # @param nb_dev [Float]  Nb of deviations (default: 1.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method wclprice(price_hlc)
+    # Weighted Close Price
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method willr(price_hlc, time_period: 14.0)
+    # Williams' %R
+    #
+    # @param price_hlc [Array(Array<Float>, Array<Float>, Array<Float>)]  Required price arrays: high, low, close
+    # @param time_period [Integer]  Number of period (default: 14.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    # @!method wma(real, time_period: 30.0)
+    # Weighted Moving Average
+    #
+    # @param real [Array<Float>]  Input values
+    # @param time_period [Integer]  Number of period (default: 30.0)
+    # @return [Array<Float>]
+    # @raise [TALibError]  If there is an error in function execution
+
+    ### GENERATED DOCUMENTATION END ###
+  end
 end